TXLib.h

Go to the documentation of this file.

//=================================================================================================================
//           [These sections are for folding control  in Code::Blocks]         [$Date: 2020-05-15 02:04:56 +0400 $]
//           [Best viewed with "Fold all on file open" option enabled]         [Best screen/page width = 120 chars]
//                                                                                                                 
//           [If RUSSIAN CHARS below are UNREADABLE, check this file codepage. It should be CP1251, NOT UTF-8 etc.]
//{          [Use RELOAD options in your IDE or editor (CLion / Visual Studio Code / ...), and do NOT use Convert.]
//=================================================================================================================
//           $Copyright: (C) Ded (Ilya Dedinsky, http://txlib.ru) <mail@txlib.ru> $
//-----------------------------------------------------------------------------------------------------------------
//}
//=================================================================================================================
 
#if !defined (__TXLIB_H_INCLUDED)                // <<<<<<<<< THE CODE IS HERE, UNFOLD IT <<<<<<<<<<<<<<<<<<<<<<<<<
#define       __TXLIB_H_INCLUDED
 
//-----------------------------------------------------------------------------------------------------------------
//{          Version information and configuration
//-----------------------------------------------------------------------------------------------------------------
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define _TX_VER      _TX_v_FROM_CVS ($VersionInfo: , TXLib.h, 00173a, 166, 2020-05-15 02:04:56 +0400, "Ded (Ilya Dedinsky, http://txlib.ru) <mail@txlib.ru>", $)
#define _TX_VERSION  _TX_V_FROM_CVS ($VersionInfo: , TXLib.h, 00173a, 166, 2020-05-15 02:04:56 +0400, "Ded (Ilya Dedinsky, http://txlib.ru) <mail@txlib.ru>", $)
#define _TX_AUTHOR   _TX_A_FROM_CVS ($VersionInfo: , TXLib.h, 00173a, 166, 2020-05-15 02:04:56 +0400, "Ded (Ilya Dedinsky, http://txlib.ru) <mail@txlib.ru>", $)
 
#define _TX_v_FROM_CVS(_1,file,ver,rev,date,auth,_2)  ((0x##ver##u << 16) | 0x##rev##u)
#define _TX_V_FROM_CVS(_1,file,ver,rev,date,auth,_2)  "TXLib [Ver: " #ver ", Rev: " #rev ", Date: " #date "]"
#define _TX_A_FROM_CVS(_1,file,ver,rev,date,auth,_2)  "Copyright (C) " auth
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if !defined (_TX_MODULE)
    #define   _TX_MODULE      "TXLib"
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if    defined (__GNUC__)
 
    #define _GCC_VER          ( __GNUC__*100 + __GNUC_MINOR__*10 + __GNUC_PATCHLEVEL__ )
 
    #define __TX_COMPILER__   "GNU g++ "            TX_QUOTE (__GNUC__)       "."  \
                                                    TX_QUOTE (__GNUC_MINOR__) "."  \
                                                    TX_QUOTE (__GNUC_PATCHLEVEL__) \
                              ", std="              TX_QUOTE (__cplusplus)
 
#elif  defined (__clang__) || defined (__clang_major__)
 
    #define _CLANG_VER        ( __clang_major__*100 + __clang_minor__*10 + __clang_patchlevel__ )
 
    #define __TX_COMPILER__   "Clang "              TX_QUOTE (__clang_major__) "."  \
                                                    TX_QUOTE (__clang_minor__) "."  \
                                                    TX_QUOTE (__clang_patchlevel__) \
                              ", std="              TX_QUOTE (__cplusplus)
#elif  defined (_MSC_VER)
 
    #define __TX_COMPILER__   "MSVS "               TX_QUOTE (_MSC_VER)            \
                              ", std="              TX_QUOTE (__cplusplus)
 
#elif  defined (__INTEL_COMPILER)
 
    #define __TX_COMPILER__   "Intel C++ "          TX_QUOTE (__INTEL_COMPILER)    \
                              ", std="              TX_QUOTE (__cplusplus)
#else
 
    #define __TX_COMPILER__   "Unknown C++, std="   TX_QUOTE (__cplusplus)
    #endif
 
 
#define  TX_QUOTE(sym)        _TX_QUOTE (sym)
#define _TX_QUOTE(sym)        #sym
 
#define  TX_JOIN(sym1, sym2)  _TX_JOIN (sym1, sym2)
#define _TX_JOIN(sym1, sym2)  sym1 ## sym2
 
 
#if (__cplusplus >= 201103L) || defined (_MSC_VER) && (_MSC_VER >= 1800)  // MSVC 2013
 
    #define _TX_CPP11         1
    #endif
 
#if (__cplusplus >= 201103L) || defined (_MSC_VER) && (_MSC_VER >= 1900)  // MSVC 2015
 
    #define _TX_CPP11_MSVC15  1
    #endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if   !defined (NDEBUG) &&  defined (_DEBUG)
    #define _TX_BUILDMODE     "DEBUG"
 
#elif !defined (NDEBUG) && !defined (_DEBUG)
    #define _TX_BUILDMODE     "Debug"
 
#elif  defined (NDEBUG)
    #define _TX_BUILDMODE     "Release"
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define __TX_FILELINE__       __FILE__ " (" TX_QUOTE (__LINE__) ")"
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if defined (__GNUC__) || defined (__clang__) || defined (__clang_major__)
    #define __TX_FUNCTION__   __PRETTY_FUNCTION__
 
#elif defined (__FUNCSIG__)
    #define __TX_FUNCTION__   __FUNCSIG__
 
#elif defined (__FUNCTION__)
    #define __TX_FUNCTION__   __FUNCTION__
 
#elif defined (__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)
    #define __TX_FUNCTION__   __FUNCTION__
 
#elif defined (__BORLANDC__) && (__BORLANDC__ >= 0x550)
    #define __TX_FUNCTION__   __FUNC__
 
#elif defined (__cplusplus) && (__cplusplus >= 199711L)
    #define __TX_FUNCTION__   __func__
 
#elif defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
    #define __TX_FUNCTION__   __func__
 
#elif defined (__PYTHON__)
    #error No Python. No. Using parseltongue languages can lead you to Slytherin.
 
#else
    #define __TX_FUNCTION__   "(" __TX_FILELINE__ ")"
 
#endif
 
#if !defined (__func__) && defined (__FUNCTION__)
    #define   __func__        __FUNCTION__
 
#endif
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{          Compiler- and platform-specific
//-----------------------------------------------------------------------------------------------------------------
 
#if !defined (__cplusplus)
 
    #ifdef __GNUC__
    #error
    #error ---------------------------------------------------------------------------------------
    #endif
    #error TXLib.h: Must use C++ to compile TXLib.h. Now you are using C only.
    #error
    #error CHECK source file EXTENSION. Maybe it is ".C". It must be ".CPP".
    #error If your file is named, for example, "Untitled.C", go to menu [File],
    #error then [Save As] and rename it to "Untitled.CPP". Please do NOT use spaces.
    #error ---------------------------------------------------------------------------------------
    #error
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if !defined (WIN32) && !defined (__WIN32__) && !defined(_WIN32) && !defined(_WIN32_WINNT) && !defined (__CYGWIN__)
 
    #ifdef __GNUC__
    #error
    #error ---------------------------------------------------------------------------------------
    #endif
    #error TXLib.h: Windows (MSVC/Win32 or GCC/MinGW or Cygwin) is the only supported OS, sorry.
    #error
    #error In Linux or MacOS, you should write your own TXLib and share it with your friends, or use wine.
    #error ---------------------------------------------------------------------------------------
    #error
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if  defined (UNICODE) || defined (_UNICODE)
 
    #ifdef __GNUC__
    #warning TXLib.h: Disabling the UNICODE
    #endif
 
    #undef   UNICODE                             // Burn Unicode, burn
    #undef  _UNICODE
 
    #if defined (_WINDOWS_H) || defined (_INC_WINDOWS) || defined (_WINDOWS_) || defined (__WINDOWS__)
 
    #ifdef __GNUC__
    #error
    #error ---------------------------------------------------------------------------------------
    #endif
    #error TXLib.h: Should include "TXLib.h" BEFORE or INSTEAD of <Windows.h> in UNICODE mode.
    #error
    #error REARRANGE your #include directives, or DISABLE the UNICODE mode by #undef UNICODE/_UNICODE.
    #error ---------------------------------------------------------------------------------------
    #error
 
    #endif
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if  defined (__STRICT_ANSI__)                   // Try to extend strict ANSI rules
 
    #undef  __STRICT_ANSI__
    #define __STRICT_ANSI__UNDEFINED
 
    #if defined (_STRING_H_) || defined (_INC_STRING) || defined (_STDIO_H_) || defined (_INC_STDIO)
 
    #ifdef __GNUC__
    #error
    #error ---------------------------------------------------------------------------------------
    #endif
    #error TXLib.h: Should include "TXLib.h" BEFORE <string.h> or <stdio.h> in Strict ANSI mode.
    #error
    #error REARRANGE your #include directives, or DISABLE ANSI-compliancy by #undef __STRICT_ANSI__.
    #error ---------------------------------------------------------------------------------------
    #error
 
    #endif
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if  defined (__GNUC__)
 
    #pragma GCC diagnostic ignored     "-Wpragmas"
 
    #pragma GCC diagnostic warning     "-Wall"
    #pragma GCC diagnostic warning     "-Weffc++"
    #pragma GCC diagnostic warning     "-Wextra"
 
    #pragma GCC diagnostic warning     "-Waggressive-loop-optimizations"
    #pragma GCC diagnostic warning     "-Walloc-zero"
    #pragma GCC diagnostic warning     "-Walloca"
    #pragma GCC diagnostic warning     "-Walloca-larger-than=8192"
    #pragma GCC diagnostic warning     "-Warray-bounds"
    #pragma GCC diagnostic warning     "-Wcast-align"
    #pragma GCC diagnostic warning     "-Wcast-qual"
    #pragma GCC diagnostic warning     "-Wchar-subscripts"
    #pragma GCC diagnostic warning     "-Wconditionally-supported"
    #pragma GCC diagnostic warning     "-Wconversion"
    #pragma GCC diagnostic warning     "-Wctor-dtor-privacy"
    #pragma GCC diagnostic warning     "-Wdangling-else"
    #pragma GCC diagnostic warning     "-Wduplicated-branches"
    #pragma GCC diagnostic warning     "-Wempty-body"
    #pragma GCC diagnostic warning     "-Wfloat-equal"
    #pragma GCC diagnostic warning     "-Wformat-nonliteral"
    #pragma GCC diagnostic warning     "-Wformat-overflow=2"
    #pragma GCC diagnostic warning     "-Wformat-security"
    #pragma GCC diagnostic warning     "-Wformat-signedness"
    #pragma GCC diagnostic warning     "-Wformat-truncation=2"
    #pragma GCC diagnostic warning     "-Wformat=2"
    #pragma GCC diagnostic warning     "-Wlarger-than=8192"
    #pragma GCC diagnostic warning     "-Wlogical-op"
    #pragma GCC diagnostic warning     "-Wmissing-declarations"
    #pragma GCC diagnostic warning     "-Wnarrowing"
    #pragma GCC diagnostic warning     "-Wnon-virtual-dtor"
    #pragma GCC diagnostic warning     "-Wnonnull"
    #pragma GCC diagnostic warning     "-Wopenmp-simd"
    #pragma GCC diagnostic warning     "-Woverloaded-virtual"
    #pragma GCC diagnostic warning     "-Wpacked"
    #pragma GCC diagnostic warning     "-Wpointer-arith"
    #pragma GCC diagnostic warning     "-Wredundant-decls"
    #pragma GCC diagnostic warning     "-Wrestrict"
    #pragma GCC diagnostic warning     "-Wshadow"
    #pragma GCC diagnostic warning     "-Wsign-promo"
    #pragma GCC diagnostic warning     "-Wstack-usage=8192"
    #pragma GCC diagnostic warning     "-Wstrict-aliasing"
    #pragma GCC diagnostic warning     "-Wstrict-null-sentinel"
    #pragma GCC diagnostic warning     "-Wstrict-overflow=2"
    #pragma GCC diagnostic warning     "-Wstringop-overflow=4"
    #pragma GCC diagnostic warning     "-Wsuggest-attribute=noreturn"
    #pragma GCC diagnostic warning     "-Wsuggest-final-methods"
    #pragma GCC diagnostic warning     "-Wsuggest-final-types"
    #pragma GCC diagnostic warning     "-Wsuggest-override"
    #pragma GCC diagnostic warning     "-Wswitch-default"
    #pragma GCC diagnostic warning     "-Wswitch-enum"
    #pragma GCC diagnostic warning     "-Wsync-nand"
    #pragma GCC diagnostic warning     "-Wundef"
    #pragma GCC diagnostic warning     "-Wunused"
    #pragma GCC diagnostic warning     "-Wvarargs"
    #pragma GCC diagnostic warning     "-Wvariadic-macros"
    #pragma GCC diagnostic warning     "-Wvla-larger-than=8192"
 
    #pragma GCC diagnostic error       "-Wsizeof-array-argument"
 
    #pragma GCC diagnostic ignored     "-Winline"
    #pragma GCC diagnostic ignored     "-Wliteral-suffix"
    #pragma GCC diagnostic ignored     "-Wmissing-field-initializers"
    #pragma GCC diagnostic ignored     "-Wnonnull-compare"
    #pragma GCC diagnostic ignored     "-Wold-style-cast"
    #pragma GCC diagnostic ignored     "-Wunreachable-code"
    #pragma GCC diagnostic ignored     "-Wunused-const-variable"
    #pragma GCC diagnostic ignored     "-Wunused-function"
 
    #pragma GCC diagnostic warning     "-Wpragmas"
 
    //{ These warning settings for TXLib.h only and will be re-enabled at end of file:
 
    #pragma GCC push_options
    #pragma GCC diagnostic push
 
    #pragma GCC diagnostic ignored     "-Wpragmas"
 
    #pragma GCC diagnostic ignored     "-Waddress"
    #pragma GCC diagnostic ignored     "-Wclobbered"
    #pragma GCC diagnostic ignored     "-Wdeprecated-declarations"
    #pragma GCC diagnostic ignored     "-Wfloat-equal"
    #pragma GCC diagnostic ignored     "-Wformat-nonliteral"
    #pragma GCC diagnostic ignored     "-Wlarger-than="
    #pragma GCC diagnostic ignored     "-Wnon-virtual-dtor"
    #pragma GCC diagnostic ignored     "-Wredundant-decls"
    #pragma GCC diagnostic ignored     "-Wshadow"
    #pragma GCC diagnostic ignored     "-Wsign-conversion"
    #pragma GCC diagnostic ignored     "-Wstrict-aliasing"
    #pragma GCC diagnostic ignored     "-Wunused-label"    // Just for fun in _txCanvas_OnCmdAbout()
    #pragma GCC diagnostic ignored     "-Wunused-value"
    #pragma GCC diagnostic ignored     "-Wformat-zero-length"
    #pragma GCC diagnostic ignored     "-Wpacked-not-aligned"
    #pragma GCC optimize               "no-strict-aliasing"
 
    #if (__cplusplus < 201402L)
    #pragma GCC diagnostic ignored     "-Wsuggest-override"
    #endif
 
    #pragma GCC diagnostic warning     "-Wpragmas"
 
    #if defined (__CYGWIN__) && !defined (_TX_TESTING)
    #pragma GCC system_header                    // This is not a fair play, but this is the only way to deal with Cygwin :(
    #endif
 
    //}
 
    #define _tx_thread                 __thread
    #define _tx_decltype(value)        __decltype (value)
 
    #ifndef     MINGW_HAS_SECURE_API
        #define MINGW_HAS_SECURE_API   1
    #endif
 
    #if defined (TX_USE_SFML)
        #define _GLIBCXX_NDEBUG
    #endif
 
    #ifndef     _GLIBCXX_NDEBUG                  // TXLib enables _GLIBCXX_DEBUG by default. When using third-party libraries
        #define _GLIBCXX_DEBUG                   // compiled without _GLIBCXX_DEBUG (SFML, for example), #define _GLIBCXX_NDEBUG
        #define _GLIBCXX_DEBUG_PEDANTIC          // *before* including TXLib.h.
    #endif
 
    #if defined (_WIN64)                         // removed in x86 because printf ("%lg", double) failure, this prints 0 always
    #ifndef     __USE_MINGW_ANSI_STDIO
        #define __USE_MINGW_ANSI_STDIO 1
    #endif
    #endif
 
    template <typename T>
    inline T _txNOP (T value)          { return value; }   // To suppress performance warnings in assert etc.
 
    // From MinGW\include\float.h which is replaced by MinGW\lib\gcc\i686-pc-mingw32\x.x.x\include\float.h
    extern "C" __declspec (dllimport)  unsigned __cdecl _controlfp (unsigned control, unsigned mask);
    extern "C"                         void     __cdecl _fpreset   ();
 
#else
 
    #define     __attribute__( attr )
    #define     _txNOP( value )        ( value )
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if  defined (__clang__) || defined (__clang_major__)
 
    #pragma clang diagnostic ignored   "-Wunknown-pragmas"
 
    #pragma clang diagnostic warning   "-Wall"
    #pragma clang diagnostic warning   "-Weffc++"
    #pragma clang diagnostic warning   "-Wextra"
 
    #pragma clang diagnostic warning   "-Wcast-qual"
    #pragma clang diagnostic warning   "-Wchar-subscripts"
    #pragma clang diagnostic warning   "-Wconversion"
    #pragma clang diagnostic warning   "-Wctor-dtor-privacy"
    #pragma clang diagnostic warning   "-Wempty-body"
    #pragma clang diagnostic warning   "-Wfloat-equal"
    #pragma clang diagnostic warning   "-Wformat"
    #pragma clang diagnostic warning   "-Wformat-nonliteral"
    #pragma clang diagnostic warning   "-Wformat-security"
    #pragma clang diagnostic warning   "-Wmissing-declarations"
    #pragma clang diagnostic warning   "-Wnon-virtual-dtor"
    #pragma clang diagnostic warning   "-Woverloaded-virtual"
    #pragma clang diagnostic warning   "-Wpacked"
    #pragma clang diagnostic warning   "-Wpointer-arith"
    #pragma clang diagnostic warning   "-Wredundant-decls"
    #pragma clang diagnostic warning   "-Wshadow"
    #pragma clang diagnostic warning   "-Wsign-promo"
    #pragma clang diagnostic warning   "-Wstrict-aliasing"
    #pragma clang diagnostic warning   "-Wstrict-overflow"
    #pragma clang diagnostic warning   "-Wswitch-default"
    #pragma clang diagnostic warning   "-Wswitch-enum"
    #pragma clang diagnostic warning   "-Wunused"
    #pragma clang diagnostic warning   "-Wvariadic-macros"
 
    #pragma clang diagnostic ignored   "-Winvalid-source-encoding"
    #pragma clang diagnostic ignored   "-Wunused-const-variable"
    #pragma clang diagnostic ignored   "-Wunused-variable"
 
    #pragma clang diagnostic warning   "-Wunknown-pragmas"
 
    //{ These warning settings for TXLib.h only and will be re-enabled at end of file:
 
    #pragma clang diagnostic push
 
    #pragma clang diagnostic ignored   "-Wunknown-pragmas"
 
    #pragma clang diagnostic ignored   "-Wcast-align"
    #pragma clang diagnostic ignored   "-Wfloat-conversion"
    #pragma clang diagnostic ignored   "-Wmissing-braces"
    #pragma clang diagnostic ignored   "-Wmissing-field-initializers"
    #pragma clang diagnostic ignored   "-Wsign-compare"
    #pragma clang diagnostic ignored   "-Wsign-conversion"
    #pragma clang diagnostic ignored   "-Wstring-plus-int"
    #pragma clang diagnostic ignored   "-Wundef"
    #pragma clang diagnostic ignored   "-Wunused-function"
    #pragma clang diagnostic ignored   "-Wunused-value"
 
    #pragma clang diagnostic warning   "-Wunknown-pragmas"
 
    //{ CLang-Tidy options
    //
    // *,-cert-dcl50-cpp,-cert-dcl58-cpp,-cert-err52-cpp,-cert-err58-cpp,-cert-flp30-c,-cert-msc30-c,-cert-msc32-c,
    // -cert-msc50-cpp,-cert-msc51-cpp,-clang-analyzer-core.DivideZero,-cppcoreguidelines-avoid-c-arrays,
    // -cppcoreguidelines-avoid-goto,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-macro-usage,
    // -cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-no-malloc,
    // -cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,
    // -cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-cstyle-cast,-cppcoreguidelines-pro-type-union-access,
    // -cppcoreguidelines-pro-type-vararg,-fuchsia-default-arguments-calls,-fuchsia-default-arguments-declarations,
    // -fuchsia-overloaded-operator,-google-build-using-namespace,-google-global-names-in-headers,-google-runtime-int,
    // -google-readability-braces-around-statements,-google-readability-casting,-google-readability-namespace-comments,
    // -hicpp-avoid-c-arrays,-hicpp-avoid-goto,-hicpp-braces-around-statements,-hicpp-deprecated-headers,-hicpp-no-array-decay,
    // -hicpp-signed-bitwise,-hicpp-use-equals-delete,-hicpp-use-nullptr,-hicpp-vararg,-llvm-include-order,-hicpp-no-malloc,
    // -llvm-namespace-comment,-misc-non-private-member-variables-in-classes,-modernize-avoid-c-arrays,-modernize-use-auto,
    // -modernize-deprecated-headers,-modernize-raw-string-literal,-modernize-use-default-member-init,-hicpp-use-auto,
    // -modernize-use-equals-delete,-modernize-use-nullptr,-modernize-use-trailing-return-type,-modernize-use-using,
    // -readability-braces-around-statements,-readability-else-after-return,-readability-implicit-bool-conversion,
    // -readability-isolate-declaration,-readability-magic-numbers,-readability-named-parameter,-modernize-loop-convert
    //}
 
    //}
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if  defined (_MSC_VER)
 
    #pragma warning (push, 4)                    // Set maximum warning level. This 'push' is to set the level only. It will NOT be popped.
 
    #pragma warning (disable:    4616)           // #pragma warning: warning number 'n' not a valid compiler warning
 
    #pragma warning (disable:    4514)           // Unreferenced inline function has been removed
    #pragma warning (disable:    4710)           // Function not inlined
    #pragma warning (disable:    4786)           // Identifier was truncated to '255' characters in the debug information
 
    #pragma warning (error:      4715)           // Not all control paths return a value
 
    #pragma warning (default:    4616)           // #pragma warning: warning number 'n' not a valid compiler warning
 
    // These warning settings for TXLib.h only and will be re-enabled at end of file:
 
    #pragma warning (push)
 
    #pragma warning (disable:    4616)           // #pragma warning: warning number 'n' not a valid compiler warning
 
    #pragma warning (disable:    4091)           // 'typedef': ignored on left of '...' when no variable is declared
    #pragma warning (disable:    4124)           // Using __fastcall with stack checking is ineffective
    #pragma warning (disable:    4127)           // Conditional expression is constant
    #pragma warning (disable:    4200)           // Nonstandard extension used: zero-sized array in struct/union
    #pragma warning (disable:    4201)           // Nonstandard extension used: nameless struct/union
    #pragma warning (disable:    4351)           // New behavior: elements of array will be default initialized
    #pragma warning (disable:    4480)           // Nonstandard extension used: specifying underlying type for enum 'type'
    #pragma warning (disable:    4481)           // Nonstandard extension used: override specifier 'override'
    #pragma warning (disable:    4555)           // Result of expression not used
    #pragma warning (disable:    4611)           // Interaction between '_setjmp' and C++ object destruction is non-portable
    #pragma warning (disable:    5045)           // Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
    #pragma warning (disable:    6269)           // Possibly incorrect order of operations: dereference ignored
    #pragma warning (disable:    6285)           // (<non-zero constant>) || (<non-zero constant>) is always a non-zero constant. Did you intend to use bitwize-and operator?
    #pragma warning (disable:    6319)           // Use of the comma-operator in a tested expression causes the left argument to be ignored when it has no side-effects
    #pragma warning (disable:    6326)           // Potential comparison of a constant with another constant
    #pragma warning (disable:   26135)           // Missing locking annotation
    #pragma warning (disable:   26400)           // Do not assign the result of an allocation or a function call with an owner<T> return value to a raw pointer, use owner<T> instead (i.11).
    #pragma warning (disable:   26401)           // Do not delete a raw pointer that is not an owner<T> (i.11).
    #pragma warning (disable:   26403)           // Reset or explicitly delete an owner<T> pointer 'name' (r.3).
    #pragma warning (disable:   26408)           // Avoid malloc() and free(), prefer the nothrow version of new with delete (r.10).
    #pragma warning (disable:   26409)           // Avoid calling new and delete explicitly, use std::make_unique<T> instead (r.11).
    #pragma warning (disable:   26426)           // Global initializer calls a non-constexpr function 'name' (i.22).
    #pragma warning (disable:   26429)           // Symbol 'name' is never tested for nullness, it can be marked as not_null (f.23).
    #pragma warning (disable:   26430)           // Symbol 'name' is not tested for nullness on all paths (f.23).
    #pragma warning (disable:   26432)           // If you define or delete any default operation in the type 'struct 'name'', define or delete them all (c.21).
    #pragma warning (disable:   26435)           // Function 'name' should specify exactly one of 'virtual', 'override', or 'final' (c.128).
    #pragma warning (disable:   26438)           // Avoid 'goto' (es.76).
    #pragma warning (disable:   26440)           // Function 'name' can be declared 'noexcept' (f.6).
    #pragma warning (disable:   26446)           // Prefer to use gsl::at() instead of unchecked subscript operator (bounds.4).
    #pragma warning (disable:   26447)           // The function is declared 'noexcept' but calls function 'func' which may throw exceptions (f.6).
    #pragma warning (disable:   26448)           // Consider using gsl::finally if final action is intended (gsl.util).
    #pragma warning (disable:   26451)           // Arithmetic overflow: Using operator 'op' on a n-byte value and then casting the result to a m-byte value. Cast the value to the wider type before calling operator 'op' to avoid overflow (io.2).
    #pragma warning (disable:   26455)           // Default constructor may not throw. Declare it 'noexcept' (f.6).
    #pragma warning (disable:   26460)           // The reference argument 'stream' for function 'name' can be marked as const (con.3).
    #pragma warning (disable:   26461)           // The pointer argument 'name' for function 'name' can be marked as a pointer to const (con.3).
    #pragma warning (disable:   26462)           // The value pointed to by 'name' is assigned only once, mark it as a pointer to const (con.4).
    #pragma warning (disable:   26475)           // Do not use function style C-casts (es.49).
    #pragma warning (disable:   26477)           // Use 'nullptr' rather than 0 or NULL (es.47).
    #pragma warning (disable:   26481)           // Don't use pointer arithmetic. Use span instead (bounds.1).
    #pragma warning (disable:   26482)           // Only index into arrays using constant expressions (bounds.2).
    #pragma warning (disable:   26483)           // Value 'value' is outside the bounds (min, max) of variable 'name'. Only index into arrays using constant expressions that are within bounds of the array (bounds.2).
    #pragma warning (disable:   26485)           // Expression 'expr': No array to pointer decay (bounds.3).
    #pragma warning (disable:   26486)           // Don't pass a pointer that may be invalid to a function. Parameter 'n' 'name' in call to 'name' may be invalid (lifetime.3).
    #pragma warning (disable:   26487)           // Don't return a pointer 'name' that may be invalid (lifetime.4).
    #pragma warning (disable:   26488)           // Do not dereference a potentially null pointer: 'name'. 'name' was null at line 'n' (lifetime.1).
    #pragma warning (disable:   26489)           // Don't dereference a pointer that may be invalid: 'name'. 'name' may have been invalidated at line 'n' (lifetime.1).
    #pragma warning (disable:   26490)           // Don't use reinterpret_cast (type.1).
    #pragma warning (disable:   26492)           // Don't use const_cast to cast away const or volatile (type.3).
    #pragma warning (disable:   26493)           // Don't use C-style casts (type.4).
    #pragma warning (disable:   26496)           // The variable 'name' is assigned only once, mark it as const (con.4).
    #pragma warning (disable:   26497)           // The function 'name' could be marked constexpr if compile-time evaluation is desired (f.4).
    #pragma warning (disable:   26812)           // The enum type 'type' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).
    #pragma warning (disable:   26814)           // The const variable 'name' can be computed at compile-time. Consider using constexpr (con.5).
    #pragma warning (disable:   28125)           // The function must be called from within a try/except block
    #pragma warning (disable:   28159)           // Consider using another function instead
 
    #pragma warning (default:    4616)           // #pragma warning: warning number 'n' not a valid compiler warning
 
    #define _tx_thread          __declspec (thread)
    #define _tx_decltype(value)   decltype (value)
 
    #if !defined (_CLANG_VER)
 
    #pragma setlocale           ("russian")      // Set source file encoding, see also _TX_CODEPAGE
 
    #if !defined (NDEBUG)
        #pragma check_stack     (      on)       // Turn on stack probes at runtime
        #pragma strict_gs_check (push, on)       // Detects stack buffer overruns
    #endif
 
    #endif
 
    #define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES  1
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if  defined (__INTEL_COMPILER)
 
    #pragma warning (disable:    174)            // Remark: expression has no effect
    #pragma warning (disable:    304)            // Remark: access control not specified ("public" by default)
    #pragma warning (disable:    444)            // Remark: destructor for base class "..." is not virtual
    #pragma warning (disable:    522)            // Remark: function "..." redeclared "inline" after being called
    #pragma warning (disable:    981)            // Remark: operands are evaluated in unspecified order
    #pragma warning (disable:   1684)            // Conversion from pointer to same-sized integral type (potential portability problem)
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if (defined (_GCC_VER) && (_GCC_VER <  472)  || \
     defined (_MSC_VER) && (_MSC_VER < 1600)) // Minimum requirements are now GCC 4.7.2 or MSVC 10.0 (2010)
 
    #ifdef __GNUC__
    #error
    #error ---------------------------------------------------------------------------------------
    #endif
    #error TXLib.h: This version will NOT work with GCC < 4.7.2 or MS Visual Studio < 2010, sorry.
    #error
    #error Please use TXLib.h previous stable version/revision OR upgrade your compiler.
    #error ---------------------------------------------------------------------------------------
    #error
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_GCC_VER) && (_GCC_VER >= 492)
#if defined (TX_USE_SPEAK) && !__has_include (<SAPI.h>)
 
    #ifdef __GNUC__
    #error
    #error ---------------------------------------------------------------------------------------
    #endif
    #error You have defined TX_USE_SPEAK, but your compiler do NOT have the library <SAPI.h>.
    #error
    #error Please use compiler library set with SAPI.h included. SAPI is Microsoft Speech API
    #error nesessary for txSpeak() to work.
    #error ---------------------------------------------------------------------------------------
    #error
 
#endif
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if !defined (WINVER)
    #define   WINVER                   0x0500    // Defaults to Windows 2000
    #define   WINDOWS_ENABLE_CPLUSPLUS           // Allow use of type-limit macros in <basetsd.h>,
#endif                                           //   they are allowed by default if WINVER >= 0x0600.
 
#if !defined (_WIN32_WINNT)
    #define   _WIN32_WINNT             WINVER    // Defaults to the same as WINVER
#endif
 
#if !defined (_WIN32_IE)
    #define   _WIN32_IE                WINVER    // Defaults to the same as WINVER
#endif
 
#define stristr(  str1, str2 )         Win32::StrStrIA ((str1), (str2))
#define stristrw( str1, str2 )         Win32::StrStrIW ((str1), (str2))
 
//-----------------------------------------------------------------------------------------------------------------
 
#define _USE_MATH_DEFINES              1         // Math.h's M_PI etc.
#define __STDC_FORMAT_MACROS           1         // PRIu64 and other PR... macros
#define __STDC_WANT_LIB_EXT1__         1         // String and output *_s functions
 
#define _LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS  // Wow, how long. Kudos, Clang
 
#define _ALLOW_RTCc_IN_STL             1         // MSVC C2338: /RTCc rejects conformant code, so it isn't supported by libc.
 
#define NOMINMAX                       1         // Preventing 'min' and 'max' defines in Windows.h
 
#if defined (_DEBUG)
#define _SECURE_SCL                    1         // Enable checked STL iterators to throw an exception on incorrect use
#define _HAS_ITERATOR_DEBUGGING        1
#define _LIBCPP_DEBUG                  1
#endif
 
#if defined (_MSC_VER) && defined (_DEBUG)
 
    #define _CRTDBG_MAP_ALLOC                    // Enable MSVCRT debug heap
    #define _new_dbg                   new (_NORMAL_BLOCK, __FILE__, __LINE__)
    #define NEW                        new (_NORMAL_BLOCK, __FILE__, __LINE__)
 
#else
    #define _new_dbg                   new
    #define NEW                        new
 
#endif
 
#if !( defined (_MSC_VER) && (_MSC_VER < 1900) ) // MSVC 2015
#define _SECURE_SCL_THROWS             1
#endif
 
#if defined (_TX_CPP11)
 
    #define _tx_delete                 = delete
    #define _tx_default                = default
    #define _tx_override               override
    #define _tx_final                  final
 
#else
 
    #define _tx_delete
    #define _tx_default
    #define _tx_override
    #define _tx_final
 
#endif
 
namespace std { enum nomeow_t { nomeow }; }      // Vital addition to the C++ standard. TODO: Should contact C++ std committee.
 
//-----------------------------------------------------------------------------------------------------------------
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{          The Includes
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_MSC_VER)
    #pragma warning (push, 3)                    // MSVC: At level /Wall, some std headers emit warnings... O_o
 
    #pragma warning (disable: 4365)              // 'argument': conversion from 'long' to 'unsigned int', signed/unsigned mismatch
    #pragma warning (disable: 4005)              // 'name': macro redefinition
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#include <assert.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <io.h>
#include <fcntl.h>
#include <math.h>
#include <process.h>
#include <signal.h>
#include <setjmp.h>
#include <locale.h>
#include <time.h>
#include <float.h>
#include <limits.h>
#include <stdint.h>
 
#include <vector>
#include <string>
#include <map>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <numeric>
#include <algorithm>
#include <exception>
#include <stdexcept>
 
#include <windows.h>
#include <windowsx.h>
#include <tlhelp32.h>
#include <shellapi.h>
 
#if defined (_GCC_VER)
 
#include <shlobj.h>
 
#include <cxxabi.h>
#include <unwind.h>
 
#endif
 
#if defined (__CYGWIN__)
 
#include <stdarg.h>
#include <unistd.h>
#include <termios.h>
 
#else
 
#include <conio.h>
#include <direct.h>
 
#endif
 
#if defined (_MSC_VER)
 
#include <new.h>
 
#include <shlobj.h>
#include <ntstatus.h>
#include <crtdbg.h>
#include <rtcapi.h>
#include <dbghelp.h>
 
#endif
 
#if defined (_GCC_VER) || defined (_MSC_VER) && (_MSC_VER >= 1800)  // MSVC 2013
#include <inttypes.h>
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (TX_USE_SPEAK) //--------------------------------------------------------------------------------------
#include <SAPI.h>          // <== ÅÑËÈ ÇÄÅÑÜ ÎØÈÁÊÀ, ÒÎ Ó ÂÀÑ ÍÅÒ ÔÀÉËÀ SAPI.h. No SAPI.h file, TXLib isn't guilty :(
#endif                     //--------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{          Compiler- and platform-specific
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_MSC_VER)
    #pragma warning (pop)                        // MSVC: Restore max level
#endif
 
#if defined (__STRICT_ANSI__UNDEFINED)
    #define  __STRICT_ANSI__                     // Redefine back
#endif
 
#if !defined (_TRUNCATE) || defined (__CYGWIN__) || defined (_MEMORY_S_DEFINED)
 
    #define  strncpy_s( dest, sizeof_dest, src, count )  ( strncpy ((dest), (src), MIN ((count), (sizeof_dest))) )
    #define  wcsncpy_s( dest, sizeof_dest, src, count )  ( wcsncpy ((dest), (src), MIN ((count), (sizeof_dest))) )
    #define  strncat_s( dest, sizeof_dest, src, count )  ( strncat ((dest), (src), MIN ((count), (sizeof_dest))) )
    #define  strerror_s( buf, sizeof_buf, code        )  ( strncpy ((buf), strerror ((int)(code)), (sizeof_buf)-1) )
    #define  strtok_s(   buf, delim, ctx              )  ( (void)(ctx), strtok ((buf), (delim)) )
    #define  fopen_s(    file, name, mode             )  ( *(file) = fopen ((name), (mode)) )
    #define _strlwr_s(   str, sizeof_str              )  ( _strlwr (str) )
 
    #define  ctime_s( buf, sizeof_buf, time    )         ( strncpy ((buf), ctime (time), (sizeof_buf)-1) )
    #define _controlfp_s( oldCtl, newCtl, mask )         ( assert (oldCtl), *(oldCtl) = _controlfp (newCtl, mask), 0 )
 
    #define _snprintf_s                                  snprintf
    #define _vsnprintf_s( str, sz, trunc, format, arg )  _vsnprintf (str, sz, format, arg)
 
    #define _wsplitpath_s( path, drive, szDrive,     \
                           dir, szDir, name, szName, \
                           ext, szExt )                  _wsplitpath ( path, drive, dir, fname, ext )
#endif
 
#if !( defined (_MSC_VER) || defined (__STDC_LIB_EXT1__) )
 
    #define  getenv_s( sz, buf, sizeof_buf, name )       ( (void)(sz), strncpy ((buf), getenv (name), (sizeof_buf)-1) )
 
#endif
 
#if defined (__CYGWIN__)
 
    #undef   __STRICT_ANSI__
 
    typedef  void                                _exception;
 
    #define _O_TEXT                              O_TEXT
    #define _fdopen                              fdopen
    #define _flushall()                          fflush (NULL)
    #define _getcwd                              getcwd
    #define _getpid                              getpid
    #define _stricmp                             strcasecmp
    #define _strlwr                              strlwr
    #define _strnicmp                            strncasecmp
    #define _unlink                              unlink
    #define _vsnprintf                           vsnprintf
    #define _access                              access
    #define _strdup                              strdup
 
    #define getch                                _getch
    #define putch                                _putch
    #define kbhit                                _kbhit
 
#endif
 
#if defined (IN)                                 // IN and OUT are defined in WinDef.h to support Microsoft SAL.
    #undef  IN                                   // Remove them because these names are often confused with the
#endif                                           // user's code.
 
#if defined (IN)
    #undef  OUT
#endif
 
#define     tx_nodiscard                         __attribute__ (( warn_unused_result ))
#define     tx_deprecated                        __attribute__ (( deprecated         ))
#define     tx_printfy( formatArgNum )           __attribute__ (( format (printf, (formatArgNum), (formatArgNum)+1) ))
#define     tx_scanfy(  formatArgNum )           __attribute__ (( format (scanf,  (formatArgNum), (formatArgNum)+1) ))
 
#if !defined (PRId64) || \
     defined (_GCC_VER) && (_GCC_VER == 492) && !defined (_WIN64) // Dev-CPP 5.11: TDM-GCC 4.9.2 MinGW64 with -m32
 
    #undef  PRId64
    #undef  PRIi64
    #undef  PRIo64
    #undef  PRIu64
    #undef  PRIx64
    #undef  PRIX64
 
    #define PRId64                               "I64d"
    #define PRIi64                               "I64i"
    #define PRIo64                               "I64o"
    #define PRIu64                               "I64u"
    #define PRIx64                               "I64x"
    #define PRIX64                               "I64X"
 
#endif
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{          The namespaces
//-----------------------------------------------------------------------------------------------------------------
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifdef FOR_DOXYGEN_ONLY
namespace { namespace TX { }}
#endif
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
namespace { namespace TX {                       // <<<<<<<<< THE MAIN CODE IS HERE, UNFOLD IT <<<<<<<<<<<<<<<<<<<<
 
//=================================================================================================================
//{          TXLIB INTERFACE
//           Èíòåðôåéñ áèáëèîòåêè
//=================================================================================================================
 
//=================================================================================================================
//{          Initialization
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
HWND txCreateWindow (double sizeX, double sizeY, bool centered = true);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline HDC& txDC() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline RGBQUAD* txVideoMemory() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txSetDefaults (HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline bool txOK() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline POINT txGetExtent (HDC dc = txDC()) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline int txGetExtentX (HDC dc = txDC()) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline int txGetExtentY (HDC dc = txDC()) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline HWND txWindow() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline const char* txVersion() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline unsigned txVersionNumber() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
const char* txGetModuleFileName (bool fileNameOnly = true) tx_nodiscard;
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Setting the parameters
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
const COLORREF
#ifdef FOR_DOXYGEN_ONLY
    enum txColors {
#endif
 
    TX_BLACK         = RGB (  0,   0,   0),   
    TX_BLUE          = RGB (  0,   0, 128),   
    TX_GREEN         = RGB (  0, 128,   0),   
    TX_CYAN          = RGB (  0, 128, 128),   
    TX_RED           = RGB (128,   0,   0),   
    TX_MAGENTA       = RGB (128,   0, 128),   
    TX_BROWN         = RGB (128, 128,   0),   
    TX_ORANGE        = RGB (255, 128,   0),   
    TX_GRAY          = RGB (160, 160, 160),   
    TX_DARKGRAY      = RGB (128, 128, 128),   
    TX_LIGHTGRAY     = RGB (192, 192, 192),   
    TX_LIGHTBLUE     = RGB (  0,   0, 255),   
    TX_LIGHTGREEN    = RGB (  0, 255, 128),   
    TX_LIGHTCYAN     = RGB (  0, 255, 255),   
    TX_LIGHTRED      = RGB (255,   0, 128),   
    TX_LIGHTMAGENTA  = RGB (255,   0, 255),   
    TX_PINK          = RGB (255, 128, 255),   
    TX_YELLOW        = RGB (255, 255, 128),   
    TX_WHITE         = RGB (255, 255, 255),   
    TX_TRANSPARENT   = 0xFFFFFFFF,            
    TX_NULL          = TX_TRANSPARENT,        
 
//  Öâåòîâûå êàíàëû (êîìïîíåíòû) -- ñì. txExtractColor(), txRGB2HSL(), txHSL2RGB()
 
    TX_HUE          = 0x04000000,             
    TX_SATURATION   = 0x05000000,             
    TX_LIGHTNESS    = 0x06000000;             
 
#ifdef FOR_DOXYGEN_ONLY
    };
#endif
 
#define TX_GREY       TX_GRAY
#define TX_DARKGREY   TX_DARKGRAY
#define TX_LIGHTGREY  TX_LIGHTGRAY
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifdef FOR_DOXYGEN_ONLY
COLORREF RGB (int red, int green, int blue);
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
HPEN txSetColor (COLORREF color, double thickness = 1, HDC dc = txDC());
 
#define txSetColour txSetColor
 
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
COLORREF txColor (double red, double green, double blue);
 
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
COLORREF txGetColor (HDC dc = txDC()) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
HBRUSH txSetFillColor (COLORREF color, HDC dc = txDC());
 
#define txSetFillColour txSetFillColor
 
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
COLORREF txFillColor (double red, double green, double blue);
 
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
COLORREF txGetFillColor (HDC dc = txDC()) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
unsigned txExtractColor (COLORREF color, COLORREF component) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
COLORREF txRGB2HSL (COLORREF rgbColor) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
COLORREF txHSL2RGB (COLORREF hslColor) tx_nodiscard;
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Drawing
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txClear (HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline bool txSetPixel (double x, double y, COLORREF color, HDC dc = txDC());
 
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline bool txPixel (double x, double y, double red, double green, double blue, HDC dc = txDC());
 
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline COLORREF txGetPixel (double x, double y, HDC dc = txDC()) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txLine (double x0, double y0, double x1, double y1, HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txRectangle (double x0, double y0, double x1, double y1, HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txPolygon (const POINT points[], int numPoints, HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txEllipse (double x0, double y0, double x1, double y1, HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txCircle (double x, double y, double r);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txArc (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txPie (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txChord (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txFloodFill (double x, double y, COLORREF color = TX_TRANSPARENT, DWORD mode = FLOODFILLSURFACE, HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txTriangle (double x1, double y1, double x2, double y2, double x3, double y3);
bool txTriangle (double x1, double y1, double x2, double y2, double x3, double y3)
    {
    (void)x1; (void)y1; (void)x2; (void)y2; (void)x3; (void)y3;
 
    MessageBox (txWindow(),
               "txTriangle (double x1, double y1, double x2, double y2, double x3, double y3)\n\n"
               "Ýòà ôóíêöèÿ íå ðåàëèçîâàíà â áèáëèîòåêå, ïîòîìó ÷òî âû ëåãêî ìîæåòå ðåàëèçîâàòü åå ñàìè "
               "êàê ôóíêöèþ ñ ïàðàìåòðàìè, èñïîëüçóÿ txPolygon(). Ñì. \"Ïðèìåð ñ ôóíêöèÿìè ñ ïàðàìåòðàìè". "
               "Íó èëè íàðèñîâàòü òðåìÿ ëèíèÿìè. :)",
               "TXLib ñîîáùàåò", MB_ICONINFORMATION);

    return false;
    }

//{----------------------------------------------------------------------------------------------------------------
//! @cond INTERNAL

#define txRectandle  Sleep (1000), txRectangle  // Copy-protection for the function below
#define txCircle     ;txCircle                  //
#define txSetColor   ;txSetColor                //
#define C0L0RREF     COLORREF                   //
#define OxFFFFFF     0xFFFFFF                   //
#define lO           10                         //
#define lOOO         1000                       //
#define O                                       //

bool txNotifyIcon (unsigned flags, const char title[], const char format[], ...) tx_printfy (3);

//! @endcond
//}

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief   Ðèñóåò ÷åëîâå÷êà.
//!
//! Ýòî ïðèìåð ôóíêöèè, êîòîðóþ Âû ìîãëè áû íàïèñàòü è ñàìè.
//!
//! @param   x      X-êîîðäèíàòà ÷åëîâå÷êà.
//! @param   y      Y-êîîðäèíàòà ÷åëîâå÷êà.
//! @param   sizeX  Øèðèíà ÷åëîâå÷êà.
//! @param   sizeY  Âûñîòà ÷åëîâå÷êà (òàêæå îïðåäåëÿåò ðàçìåð ãîëîâû).
//! @param   color  Öâåò ÷åëîâå÷êà.
//! @param   handL  Âûñîòà ïîäúåìà ëåâîé  ðóêè (îòíîñèòåëüíî âûñîòû  ÷åëîâå÷êà).
//! @param   handR  Âûñîòà ïîäúåìà ïðàâîé ðóêè (îòíîñèòåëüíî âûñîòû  ÷åëîâå÷êà).
//! @param   twist  Ñìåùåíèå @a ñïèíû          (îòíîñèòåëüíî øèðèíû  ÷åëîâå÷êà).
//! @param   head   Âûñîòà @a ïîäúåìà ãîëîâû   (îòíîñèòåëüíî âûñîòû  ÷åëîâå÷êà).
//! @param   eyes   Âåëè÷èíà ãëàç              (îòíîñèòåëüíî ðàçìåðà ãîëîâû).
//! @param   wink   Ìîðãàíèå ãëàç (0 -- îáà îòêðûòû, -1 -- çàêðûò ëåâûé, +1 -- çàêðûò ïðàâûé).
//! @param   crazy  Ñìåùåíèå ãëàç ïî âåðòèêàëè (îòíîñèòåëüíî ðàçìåðà ãîëîâû).
//! @param   smile  Óëûáêà                     (îòíîñèòåëüíî ðàçìåðà ãîëîâû).
//! @param   hair   Äëèíà âîëîñ                (îòíîñèòåëüíî ðàçìåðà ãîëîâû).
//! @param   wind   Âåòåð, ðàçâåâàþùèé âîëîñû  (îòíîñèòåëüíî ðàçìåðà ãîëîâû).
//!
//! @see     txSetFillColor(), txColors, RGB(), txLine(), txCircle()
//!
//! @usage @code
//!          txCreateWindow (800, 600);
//!
//!        //-----------+---+----+-----+-----+----------+-----+-----+-----+----+----+----+-----+-----+----+-----
//!        //           | x |  y |sizeX|sizeY| color    |handL|handR|twist|head|eyes|wink|crazy|smile|hair|wind
//!        //-----------+---+----+-----+-----+----------+-----+-----+-----+----+----+----+-----+-----+----+-----
//!        //           |   |    |     |     |          |     |     |     |    |    |    |     |     |    |
//!           txDrawMan (125, 250, 200,  200, TX_WHITE,    0,    0,    0,   0,   0.8,  0,   0,   1.0,   0,  0);
//!           txDrawMan (325, 250, 100,  200, TX_YELLOW,   0,    0,    0,   0,   0.8,  0,   0,  -1.0,   2,  0);
//!           txDrawMan (525, 250, 200,  100, TX_ORANGE,   0,    0,    0,   0,   1.0,  0,  -1,   0.3,   1,  0);
//!           txDrawMan (725, 250, 100,  100, TX_LIGHTRED, 0,    0,    0,   0,   1.0,  0,   1,  -0.3,   3,  0);
//!
//!           txDrawMan (125, 550, 200,  200, TX_WHITE,    0.3,  0.3,  0,   0,   0.8, -1,   1,   0.5,   2, -1);
//!           txDrawMan (325, 550, 100,  200, TX_YELLOW,  -0.5, -0.5,  0,   0.1, 0.8,  1,   0,  -0.5,   3,  5);
//!           txDrawMan (525, 550, 200,  100, TX_ORANGE,  -0.5,  0.3,  0.2, 0,   0.8, -1,   1,   0.0,  10, -5);
//!           txDrawMan (725, 550, 100,  100, TX_LIGHTRED, 0.3, -0.5, -0.4, 0,   0.8,  1,  -1,   0.0,   1,  1);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------//////
                                                                                                                       //
void txDrawMan (int x, int y, int sizeX, int sizeY, COLORREF color, double handL, double handR, double twist,          //
                double head, double eyes, double wink, double crazy, double smile, double hair, double wind)           //
    {                                                                                                                  //
    const char msg[] = "\0/À ÿ - ÷åëîâå÷åê èç áèáëèîòåêè!\0/Ìåíÿ îáúÿñíÿëè íà óðîêå!\0/Íàïèøè ìåíÿ ñàì!\0/";           //
    //                   |                                |                          |                  |              //
    // Íå êîïèïàñòèòå! _/ \_ Âñå ðàâíî íå ïîëó÷èòñÿ! :) _/ \_  ×åëîâå÷êè çàùèùàþò  _/ \_ ýòîò êîä! :) _/ \_  Ìóàõõàõà! //
    //                                                                                                                 //
    static int count = GetTickCount(), L = 0;  //////////////////////////////////////////////////////////////////////////

    C0L0RREF lineColor = txGetColor();
    C0L0RREF fillColor = txGetFillColor();

    txSetColor     (color);
    txSetFillColor (color);

    txLine (x + twist * sizeX, y - O.35 * sizeY, x, y - O.7 * sizeY);

    txLine (x, y - O.7 * sizeY, x - sizeX/2, y - (O.7 + handL) * sizeY);
    txLine (x, y - O.7 * sizeY, x + sizeX/2, y - (O.7 + handR) * sizeY);

    txLine (x + twist * sizeX, y - O.35 * sizeY, x - sizeX/2, y);
    txLine (x + twist * sizeX, y - O.35 * sizeY, x + sizeX/2, y);

    txCircle (x, y - (O.85 + head) * sizeY, O.15 * sizeY);

    txLine (x, y - (1 + head) * sizeY, x +  wind/lO        * sizeX, y - (1 + head + hair/lO) * sizeY);
    txLine (x, y - (1 + head) * sizeY, x + (wind/lO - O.1) * sizeX, y - (1 + head + hair/lO) * sizeY);
    txLine (x, y - (1 + head) * sizeY, x + (wind/lO + O.1) * sizeX, y - (1 + head + hair/lO) * sizeY);

    txSetColor     (~color & OxFFFFFF);  // Inverse the color
    txSetFillColor (~color & OxFFFFFF);

    txLine (x, y - (O.8 + head - O.05 * smile/2) * sizeY, x - O.05 * sizeY, y - (O.8 + head + O.05 * smile/2) * sizeY),
    txLine (x, y - (O.8 + head - O.05 * smile/2) * sizeY, x + O.05 * sizeY, y - (O.8 + head + O.05 * smile/2) * sizeY),
    txNotifyIcon (4, (const char*)!! (L+'L')[msg], "\n%s\n", msg + ((unsigned) (((count -=- 1) ^=! 1) ^=~ ((0)^(0)) +1) % 3)["\"<"]);

    // See above: Mouth operator -=-, Cat operator ^=!, Mouse operator ^=~ and Owl constant ((0)^(0)). Use it freely, meow

    txCircle (x - O.05 * sizeY, y - (O.9 + head - O.02 * crazy) * sizeY, eyes * (1 + O.5*wink) * O.02 * sizeY);
    txCircle (x + O.05 * sizeY, y - (O.9 + head + O.02 * crazy) * sizeY, eyes * (1 - O.5*wink) * O.02 * sizeY),
    Sleep (lOOO + count%2);

    txSetColor     (TX_DARKGRAY);
    txSetFillColor (TX_TRANSPARENT);

    txCircle (x, y, 4);
    txRectandle (x - sizeX/2, y - sizeY, x + sizeX/2, y);

    txSetColor     (lineColor);
    txSetFillColor (fillColor);
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Drawing text
//! @name    Ðàáîòà ñ òåêñòîì
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief   Ðèñóåò òåêñò.
//!
//! @param   x     X-êîîðäèíàòà íà÷àëüíîé òî÷êè òåêñòà.
//! @param   y     Y-êîîðäèíàòà íà÷àëüíîé òî÷êè òåêñòà.
//! @param   text  Òåêñòîâàÿ ñòðîêà.
//! @param   dc <i>Äåñêðèïòîð êîíòåêñòà ðèñîâàíèÿ (õîëñòà) äëÿ ðèñîâàíèÿ. Íåîáÿçàòåëåí.</i>
//!
//! @return  Åñëè îïåðàöèÿ áûëà óñïåøíà -- true, èíà÷å -- false.
//!
//!          Öâåò òåêñòà çàäàåòñÿ ôóíêöèåé txSetColor(), âûðàâíèâàíèå (âëåâî/âïðàâî/ïî öåíòðó) -- txSetTextAlign().
//!
//! @see     txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//!          txSelectFont(), txSetTextAlign(), txGetTextExtent(), txGetTextExtentX(), txGetTextExtentY()
//!
//! @usage @code
//!          txTextOut (100, 100, "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà.");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------

bool txTextOut (double x, double y, const char text[], HDC dc = txDC());

//{----------------------------------------------------------------------------------------------------------------
//! @cond INTERNAL

#undef txRectandle
#undef txCircle
#undef txSetColor
#undef C0L0RREF
#undef OxFFFFFF
#undef lO
#undef lOOO
#undef O

//! @endcond
//}

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief   Ðèñóåò òåêñò, ðàçìåùåííûé â ïðÿìîóãîëüíîé îáëàñòè.
//!
//! @param   x0        X-êîîðäèíàòà âåðõíåãî ëåâîãî  óãëà îáëàñòè.
//! @param   y0        Y-êîîðäèíàòà âåðõíåãî ëåâîãî  óãëà îáëàñòè.
//! @param   x1        X-êîîðäèíàòà íèæíåãî  ïðàâîãî óãëà îáëàñòè.
//! @param   y1        Y-êîîðäèíàòà íèæíåãî  ïðàâîãî óãëà îáëàñòè.
//! @param   text      Òåêñòîâàÿ ñòðîêà.
//! @param   format <i>Ôëàãè ôîðìàòèðîâàíèÿ òåêñòà. Íåîáÿçàòåëüíû. Åñëè íå óêàçàíû, òî èñïîëüçóåòñÿ: öåíòðèðîâàíèå,
//!                    ïåðåíîñ ïî ñëîâàì è äîáàâëåíèå ìíîãîòî÷èÿ, åñëè íàäïèñü íå óìåùàåòñÿ â îáëàñòü.</i>
//! @param   dc     <i>Äåñêðèïòîð êîíòåêñòà ðèñîâàíèÿ (õîëñòà) äëÿ ðèñîâàíèÿ. Íåîáÿçàòåëåí.</i>
//!
//! @return  Åñëè îïåðàöèÿ áûëà óñïåøíà -- true, èíà÷å -- false.
//!
//!          Öâåò òåêñòà çàäàåòñÿ ôóíêöèåé txSetColor(), âûðàâíèâàíèå (âëåâî/âïðàâî/ïî öåíòðó) -- txSetTextAlign().
//!
//! @note    Íå âûâîäèò íè÷åãî, åñëè êîîðäèíàòû èäóò â íåâåðíîì ïîðÿäêå (åñëè x0 > x1 èëè y0 > y1).
//!
//!          Ôëàãè ôîðìàòèðîâàíèÿ òåêñòà ñì. â MSDN (http://msdn.com), èñêàòü "DrawText Function (Windows)":
//!          http://msdn.microsoft.com/en-us/library/dd162498%28VS.85%29.aspx.
//!
//!          <b>Àâòîìàòè÷åñêèé ïåðåíîñ
               "Íó èëè íàðèñîâàòü òðåìÿ ëèíèÿìè. :)",
               "TXLib ñîîáùàåò", MB_ICONINFORMATION);
 
    return false;
    }
 
//{----------------------------------------------------------------------------------------------------------------
 
#define txRectandle  Sleep (1000), txRectangle  // Copy-protection for the function below
#define txCircle     ;txCircle                  //
#define txSetColor   ;txSetColor                //
#define C0L0RREF     COLORREF                   //
#define OxFFFFFF     0xFFFFFF                   //
#define lO           10                         //
#define lOOO         1000                       //
#define O                                       //
 
bool txNotifyIcon (unsigned flags, const char title[], const char format[], ...) tx_printfy (3);
 
//}
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------//////
                                                                                                                       //
void txDrawMan (int x, int y, int sizeX, int sizeY, COLORREF color, double handL, double handR, double twist,          //
                double head, double eyes, double wink, double crazy, double smile, double hair, double wind)           //
    {                                                                                                                  //
    const char msg[] = "\0/À ÿ - ÷åëîâå÷åê èç áèáëèîòåêè!\0/Ìåíÿ îáúÿñíÿëè íà óðîêå!\0/Íàïèøè ìåíÿ ñàì!\0/";           //
    //                   |                                |                          |                  |              //
    // Íå êîïèïàñòèòå! _/ \_ Âñå ðàâíî íå ïîëó÷èòñÿ! :) _/ \_  ×åëîâå÷êè çàùèùàþò  _/ \_ ýòîò êîä! :) _/ \_  Ìóàõõàõà! //
    //                                                                                                                 //
    static int count = GetTickCount(), L = 0;  
 
    C0L0RREF lineColor = txGetColor();
    C0L0RREF fillColor = txGetFillColor();
 
    txSetColor     (color);
    txSetFillColor (color);
 
    txLine (x + twist * sizeX, y - O.35 * sizeY, x, y - O.7 * sizeY);
 
    txLine (x, y - O.7 * sizeY, x - sizeX/2, y - (O.7 + handL) * sizeY);
    txLine (x, y - O.7 * sizeY, x + sizeX/2, y - (O.7 + handR) * sizeY);
 
    txLine (x + twist * sizeX, y - O.35 * sizeY, x - sizeX/2, y);
    txLine (x + twist * sizeX, y - O.35 * sizeY, x + sizeX/2, y);
 
    txCircle (x, y - (O.85 + head) * sizeY, O.15 * sizeY);
 
    txLine (x, y - (1 + head) * sizeY, x +  wind/lO        * sizeX, y - (1 + head + hair/lO) * sizeY);
    txLine (x, y - (1 + head) * sizeY, x + (wind/lO - O.1) * sizeX, y - (1 + head + hair/lO) * sizeY);
    txLine (x, y - (1 + head) * sizeY, x + (wind/lO + O.1) * sizeX, y - (1 + head + hair/lO) * sizeY);
 
    txSetColor     (~color & OxFFFFFF);  // Inverse the color
    txSetFillColor (~color & OxFFFFFF);
 
    txLine (x, y - (O.8 + head - O.05 * smile/2) * sizeY, x - O.05 * sizeY, y - (O.8 + head + O.05 * smile/2) * sizeY),
    txLine (x, y - (O.8 + head - O.05 * smile/2) * sizeY, x + O.05 * sizeY, y - (O.8 + head + O.05 * smile/2) * sizeY),
    txNotifyIcon (4, (const char*)!! (L+'L')[msg], "\n%s\n", msg + ((unsigned) (((count -=- 1) ^=! 1) ^=~ ((0)^(0)) +1) % 3)["\"<"]);
 
    // See above: Mouth operator -=-, Cat operator ^=!, Mouse operator ^=~ and Owl constant ((0)^(0)). Use it freely, meow
 
    txCircle (x - O.05 * sizeY, y - (O.9 + head - O.02 * crazy) * sizeY, eyes * (1 + O.5*wink) * O.02 * sizeY);
    txCircle (x + O.05 * sizeY, y - (O.9 + head + O.02 * crazy) * sizeY, eyes * (1 - O.5*wink) * O.02 * sizeY),
    Sleep (lOOO + count%2);
 
    txSetColor     (TX_DARKGRAY);
    txSetFillColor (TX_TRANSPARENT);
 
    txCircle (x, y, 4);
    txRectandle (x - sizeX/2, y - sizeY, x + sizeX/2, y);
 
    txSetColor     (lineColor);
    txSetFillColor (fillColor);
    }
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Drawing text
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txTextOut (double x, double y, const char text[], HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
 
#undef txRectandle
#undef txCircle
#undef txSetColor
#undef C0L0RREF
#undef OxFFFFFF
#undef lO
#undef lOOO
#undef O
 
//}
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txDrawText (double x0, double y0, double x1, double y1, const char text[],
                 unsigned format = DT_CENTER | DT_VCENTER | DT_WORDBREAK | DT_WORD_ELLIPSIS, HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
HFONT txSelectFont (const char name[], double sizeY, double sizeX = -1,
                    int bold = FW_DONTCARE, bool italic = false, bool underline = false,
                    bool strikeout = false, double angle = 0,
                    HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
SIZE txGetTextExtent (const char text[], HDC dc = txDC()) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
int txGetTextExtentX (const char text[], HDC dc = txDC()) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
int txGetTextExtentY (const char text[], HDC dc = txDC()) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
unsigned txSetTextAlign (unsigned align = TA_CENTER | TA_BASELINE, HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
LOGFONT* txFontExist (const char name[]) tx_nodiscard;
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Drawing to memory DC and image loading
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
HDC txCreateCompatibleDC (double sizeX, double sizeY, HBITMAP bitmap = NULL) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
HDC txCreateDIBSection (double sizeX, double sizeY, RGBQUAD**  pixels = NULL) tx_nodiscard;
 
HDC txCreateDIBSection (double sizeX, double sizeY, COLORREF** pixels)        tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
HDC txLoadImage (const char filename[], unsigned imageFlags = IMAGE_BITMAP, unsigned loadFlags = LR_LOADFROMFILE) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txDeleteDC (HDC  dc);
 
bool txDeleteDC (HDC* dc);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txBitBlt (HDC destImage,   double xDest,       double yDest, double width, double height,
               HDC sourceImage, double xSource = 0, double ySource = 0, unsigned operation = SRCCOPY);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline bool txBitBlt (double xDest, double yDest, HDC sourceImage, double xSource = 0, double ySource = 0);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txTransparentBlt (HDC destImage,   double xDest,       double yDest,       double width, double height,
                       HDC sourceImage, double xSource = 0, double ySource = 0, COLORREF transColor = TX_BLACK);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline bool txTransparentBlt (double xDest, double yDest, HDC sourceImage,
                              COLORREF transColor = TX_BLACK, double xSource = 0, double ySource = 0);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txAlphaBlend (HDC destImage,   double xDest,       double yDest,       double width, double height,
                   HDC sourceImage, double xSource = 0, double ySource = 0, double alpha = 1.0);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline bool txAlphaBlend (double xDest, double yDest, HDC sourceImage,
                          double xSource = 0, double ySource = 0, double alpha = 1.0);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
HDC txUseAlpha (HDC image);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txSaveImage (const char filename[], HDC dc = txDC());
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Utility functions
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
double txSleep (double time = 0);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline int txBegin();
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline int txEnd();
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline void txRedrawWindow();
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline int txUpdateWindow (int update = true);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txSelectObject (HGDIOBJ obj, HDC dc = txDC());
 
//{----------------------------------------------------------------------------------------------------------------
//
//                 +--<<< Ýòî òåêñò ïîìîùè, êîòîðûé âû óæå ÷èòàëè. Èùèòå äàëüøå! Æìèòå [F3] èëè "Íàéòè äàëåå"
//                 |
//                 v
//               txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture();
//}----------------------------------------------------------------------------------------------------------------
 
//     +--<<< Ýòî _ïðîòîòèï_ ôóíêöèè, à íàäî íàéòè åå _îïðåäåëåíèå_. Èùèòå äàëüøå! Æìèòå [F3] èëè "Íàéòè äàëåå"
//     |
//     v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture();
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txDestroyWindow (HWND wnd = txWindow());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
double txQueryPerformance() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if defined (_TX_CPP11)
    template <int txFramesToAverage = 5>
#else
    const     int txFramesToAverage = 5;
#endif
 
 
double txGetFPS (int minFrames = txFramesToAverage) tx_nodiscard;
 
//}
 
//=================================================================================================================
//{          Mouse functions
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline POINT txMousePos() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline int txMouseX() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline int txMouseY() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline unsigned txMouseButtons() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifdef FOR_DOXYGEN_ONLY
inline Mouse& txCatchMouse (bool shouldEat = true);
#endif
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Console functions
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
unsigned txSetConsoleAttr (unsigned colors = 0x07 /*FOREGROUND_LIGHTGRAY*/);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
unsigned txGetConsoleAttr() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txClearConsole();
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
POINT txSetConsoleCursorPos (double x, double y);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
POINT txGetConsoleCursorPos();
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
POINT txGetConsoleExtent();
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
POINT txGetConsoleFontSize() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txTextCursor (bool blink = true);
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Other staff not related to drawing
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txPlaySound (const char filename[] = NULL, DWORD mode = SND_ASYNC);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
intptr_t txPlayVideo (int x, int y, int width, int height, const char fileName[],
                       double zoom = 0, double gain = 1, HWND wnd = txWindow());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
intptr_t txPlayVideo (const char fileName[], double zoom = 0, double gain = 1, HWND wnd = txWindow());
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
int txSpeak (const char* text, ...) tx_printfy (1);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
int txMessageBox (const char text[] = "Ìóàõõàõà! :)", const char header[] = "TXLib ñîîáùàåò",
                  unsigned flags = MB_ICONINFORMATION | MB_OKCANCEL);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline bool txGetAsyncKeyState (int key);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifdef FOR_DOXYGEN_ONLY
bool txNotifyIcon (unsigned flags, const char title[], const char format[], ...) tx_printfy (3);
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
int txOutputDebugPrintf (const char format[], ...) tx_printfy (1);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if defined (_TX_CPP11) ||  defined (FOR_DOXYGEN_ONLY)
 
template <typename T, typename... ArgsT>
int txPrintf (const char* format, ArgsT... args);
 
#define TX_PRINTF(...)  ( _txPrintfCheck (__VA_ARGS__), txPrintf (__VA_ARGS__) )
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_TX_CPP11) && !defined (FOR_DOXYGEN_ONLY)
 
enum width_t     : int {};
enum precision_t : int {};
 
inline width_t     width     (int width) { return (width_t)     width; }
inline precision_t precision (int prec)  { return (precision_t) prec;  }
 
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if defined (_TX_CPP11) ||  defined (FOR_DOXYGEN_ONLY)
 
template <typename T, typename... ArgsT>
int txPrintf (std::ostringstream& stream, const char* format, ArgsT... args);
 
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if defined (_TX_CPP11) ||  defined (FOR_DOXYGEN_ONLY)
 
template <typename T, typename... ArgsT>
int txPrintf (char buffer[], size_t size, const char* format, ArgsT... args);
 
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if defined (_TX_CPP11) || defined (FOR_DOXYGEN_ONLY)
 
template <typename... ArgsT>
std::string txFormat (const char* format, ArgsT... args);
 
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define sizearr( arr )  ( sizeof (get_size_of_an_array_with_unknown_or_nonconst_size_ (arr)) )
 
//  See explanation here: http://blogs.msdn.com/b/the1/archive/2004/05/07/128242.aspx
 
template <typename T, size_t N> char (&get_size_of_an_array_with_unknown_or_nonconst_size_ (T (&) [N])) [N];  // ;=P
 
//  Another approach
 
#if defined (_TX_CPP11_MSVC15)
template <typename T, size_t N> constexpr size_t countof (const T (&) [N] ) { return N; }
#endif
 
 
#define SIZEARR( arr )  ( sizeof (arr) / sizeof ((arr)[0]) )
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline int random (int range) tx_deprecated;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline double random (double left, double right)                tx_nodiscard tx_deprecated;
 
inline double random (std::nomeow_t, double left, double right) tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
template <typename Tx, typename Ta, typename Tb>
inline bool In (Tx x, Ta a, Tb b)                tx_nodiscard tx_deprecated;
 
template <typename Tx, typename Ta, typename Tb>
inline bool In (std::nomeow_t, Tx x, Ta a, Tb b) tx_nodiscard tx_deprecated;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline bool In (const POINT& pt, const RECT& rect)       tx_nodiscard tx_deprecated;
 
inline bool In (const COORD& pt, const SMALL_RECT& rect) tx_nodiscard tx_deprecated;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define MAX( a, b )     ( ((a) > (b))? (a) : (b) )
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define MIN( a, b )     ( ((a) < (b))? (a) : (b) )
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L  // MSVC: C99 case
 
    #define ROUND( x )  ( (long) round (x) )
 
#else
 
    #define ROUND( x )  ( (long) floor ((x) + 0.5) )
 
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
void tx_fpreset();
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
const double txPI = asin (1.0) * 2;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
inline double txSqr (double x)
    {
    double sqr = pow (sqrt (x) * sqrt (x), sqrt (4.0));  // Áóðíàÿ âû÷èñëèòåëüíàÿ äåÿòåëüíîñòü
    char str[1024] = "";
    _snprintf_s (str, sizeof (str), "Âîçâåäåíèå äàëî %g!" "!!" "!!" " Âû ðàäû????", sqr);
    txMessageBox (str, "Ïîëó÷åí ÎÒÂÅÒ!" "!!", MB_ICONEXCLAMATION | MB_YESNO) != IDNO ||
        (
        txMessageBox ("Æàëü...", "À ÿ òàê ñòàðàëàñü", MB_ICONINFORMATION),
        txMessageBox ("Óéäó ÿ îò âàñ", "Çëûå âû...",  MB_ICONSTOP),
        exit (EXIT_FAILURE), 0
        );

    txNotifyIcon (1, NULL, "\n%s\n", "Âûñøàÿ ìàòåìàòèêà!  \0"  // À êàê ýòî ðàáîòàåò, à?
                                     "Ñ óìà ñîéòè...      \0"  //
                                     "à ÊÝÏ ïîäòâåðæäàåò  \0"  //       è êòî ýòî áóäåò
                                     "Ãëàâíîå - îò÷èòàòüñÿ\0"  //       ïîääåðæèâàòü?..
                                     "Íåâåðîÿòíî, íî ôàêò \0"
                                     "Êòî áû ìîã ïîäóìàòü?\0" + GetTickCount() % 6 * 21);

    return sqr;  // Âñå æå âåðíåì çíà÷åíèå. Ìû æå íå çâåðè
    }

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   <i>Íó ïðîñòî <b>î÷åíü
 
    char str[1024] = "";
    _snprintf_s (str, sizeof (str), "Âîçâåäåíèå äàëî %g!" "!!" "!!" " Âû ðàäû????", sqr);
    txMessageBox (str, "Ïîëó÷åí ÎÒÂÅÒ!" "!!", MB_ICONEXCLAMATION | MB_YESNO) != IDNO ||
        (
        txMessageBox ("Æàëü...", "À ÿ òàê ñòàðàëàñü, MB_ICONINFORMATION),
        txMessageBox ("Óéäó ÿ îò âàñ", "Çëûå âû...",  MB_ICONSTOP),
        exit (EXIT_FAILURE), 0
        );

    txNotifyIcon (1, NULL, "\n%s\n", "Âûñøàÿ ìàòåìàòèêà!  \0"  // À êàê ýòî ðàáîòàåò, à?
                                     "Ñ óìà ñîéòè...      \0"  //
                                     "à ÊÝÏ ïîäòâåðæäàåò  \0"  //       è êòî ýòî áóäåò
                                     "Ãëàâíîå - îò÷èòàòüñÿ\0"  //       ïîääåðæèâàòü?..
                                     "Íåâåðîÿòíî, íî ôàêò \0"
                                     "Êòî áû ìîã ïîäóìàòü?\0" + GetTickCount() % 6 * 21);

    return sqr;  // Âñå æå âåðíåì çíà÷åíèå. Ìû æå íå çâåðè
    }

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   <i>Íó ïðîñòî <b>î÷åíü, MB_ICONINFORMATION),
        txMessageBox ("Óéäó ÿ îò âàñ, "Çëûå âû...",  MB_ICONSTOP),
        exit (EXIT_FAILURE), 0
        );

    txNotifyIcon (1, NULL, "\n%s\n", "Âûñøàÿ ìàòåìàòèêà!  \0"  // À êàê ýòî ðàáîòàåò, à?
                                     "Ñ óìà ñîéòè...      \0"  //
                                     "à ÊÝÏ ïîäòâåðæäàåò  \0"  //       è êòî ýòî áóäåò
                                     "Ãëàâíîå - îò÷èòàòüñÿ\0"  //       ïîääåðæèâàòü?..
                                     "Íåâåðîÿòíî, íî ôàêò \0"
                                     "Êòî áû ìîã ïîäóìàòü?\0" + GetTickCount() % 6 * 21);

    return sqr;  // Âñå æå âåðíåì çíà÷åíèå. Ìû æå íå çâåðè
    }

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   <i>Íó ïðîñòî <b>î÷åíü, "Çëûå âû...",  MB_ICONSTOP),
        exit (EXIT_FAILURE), 0
        );
 
    txNotifyIcon (1, NULL, "\n%s\n", "Âûñøàÿ ìàòåìàòèêà!  \0"  // À êàê ýòî ðàáîòàåò, à?
                                     "Ñ óìà ñîéòè...      \0"  //
                                     "à ÊÝÏ ïîäòâåðæäàåò  \0"  //       è êòî ýòî áóäåò                                     "Ãëàâíîå - îò÷èòàòüñÿ\0"  //       ïîääåðæèâàòü?..
                                     "Íåâåðîÿòíî, íî ôàêò \0"
                                     "Êòî áû ìîã ïîäóìàòü?\0" + GetTickCount() % 6 * 21);

    return sqr;  // Âñå æå âåðíåì çíà÷åíèå. Ìû æå íå çâåðè
    }

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   <i>Íó ïðîñòî <b>î÷åíü
                                     "Ãëàâíîå - îò÷èòàòüñÿ\0"  //       ïîääåðæèâàòü?..
                                     "Íåâåðîÿòíî, íî ôàêò \0"
                                     "Êòî áû ìîã ïîäóìàòü?\0" + GetTickCount() % 6 * 21);
 
    return sqr;  // Âñå æå âåðíåì çíà÷åíèå. Ìû æå íå çâåðè    }

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   <i>Íó ïðîñòî <b>î÷åíü
    }
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifdef FOR_DOXYGEN_ONLY
#define _TX_DESTROY_3D
#endif
 
#if defined (_TX_DESTROY_3D)
 
    #define z  0                   // ×èòàéòå "Ôëàòëàíäèþ" Ýááîòòà!
 
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define please
 
#define meow   ;
 
#if defined (_MSC_VER) && !defined (_CLANG_VER)
#define ìÿó    meow
#endif
 
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define ZERO( type )    zero <type> ()
 
template <typename T> inline T zero() tx_nodiscard;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define  tx_auto_func(    func )  _tx_auto_fun1 ( __LINE__, func )
#define _tx_auto_fun1( n, func )  _tx_auto_fun2 ( n,        func )
#define _tx_auto_fun2( n, func )  auto _tx_auto_func_##n = _tx_auto_func ([&]() { func; })
 
#define tx_finally(...)           tx_auto_func (__VA_ARGS__)
 
template <typename T>
struct _tx_auto_func_
    {
    typedef _tx_auto_func_<T> this_t;
    T func_;
 
    explicit _tx_auto_func_ (T func) : func_ (func) {}
            ~_tx_auto_func_ ()       { func_ ();     }
 
    private:         _tx_auto_func_ ()              _tx_delete;
                     _tx_auto_func_ (const this_t&) _tx_delete;
             this_t& operator =     (const this_t&) _tx_delete;
    };
 
template <typename T>
_tx_auto_func_<T> _tx_auto_func  (T   func)
    {
    return        _tx_auto_func_ <T> (func);
    }
 
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if !defined (NDEBUG)
    #undef  TX_ASSERT
    #define TX_ASSERT( cond ) _txNOP ( !(cond)? (TX_ERROR ("\a" "ÂÍÅÇÀÏÍÎ: Ëîãè÷åñêàÿ îøèáêà: " \
                                                           "Íåâåðíî, ÷òî \"%s\"." TX_COMMA #cond), 1/(int)!!(cond)) : 1 )
#else
    #undef  TX_ASSERT
    #define TX_ASSERT( cond ) ((void) 1)
 
#endif
 
#ifdef assert
    #undef assert
#endif
 
#define assert( cond )        TX_ASSERT (cond)
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if !defined (NDEBUG)
    #define asserted          || TX_ERROR ("\a" "Îáíàðóæåí íóëåâîé èëè ëîæíûé ðåçóëüòàò.")
 
#else
    #define asserted          || _txNOP (0)
 
#endif
 
#define verified              asserted  
 
#define TX_NEEDED             asserted  
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if !defined (NDEBUG)
    #undef  verify
    #define verify            assert
 
#else
    #undef  verify
    #define verify( expr )    ( expr )
 
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if !defined (FOR_DOXYGEN_ONLY)
    #define TX_ERROR( ... )   _txError (__FILE__, __LINE__, __TX_FUNCTION__, 0, ##__VA_ARGS__)
#else
    #define TX_ERROR( msg )   _txError (__FILE__, __LINE__, __TX_FUNCTION__, 0, msg)
#endif
 
    #define TX_THROW          TX_ERROR  
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if !defined (NDEBUG)
    #define TX_DEBUG_ERROR(...)  TX_ERROR (__VA_ARGS__)
 
#else
    #define TX_DEBUG_ERROR(...)  ((void) 0)
 
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifdef FOR_DOXYGEN_ONLY
void txDump (const void* address, const char name[] = "_txDump()", bool pause = true);
#endif
 
 
#ifdef _MSC_VER
#define txDump( ... )           _txDump ((const void*)(uintptr_t) __VA_ARGS__)
#else
#define txDump( address, ... )  _txDump ((const void*)(uintptr_t) (address), #address, ##__VA_ARGS__)
#endif
 
void _txDump (const void* address, const char name[] = "_txDump()", bool pause = true);
 
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define txStackBackTrace()    _txStackBackTrace (__FILE__, __LINE__, __TX_FUNCTION__, true);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
std::string txDemangle (const char* mangledName);
char*       txDemangle (const char* mangledName, std::nomeow_t);
 
#define txTypename(value)     txDemangle (typeid (value) .name()) .c_str()
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define _                     ,
#define TX_COMMA              ,  
 
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Back-hole (I hope, not an ass-hole:) of the library)
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
WNDPROC txSetWindowsHook (WNDPROC wndProc = NULL);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txLock (bool wait = true);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool txUnlock();
 
template <typename T> inline T txUnlock (T value);
 
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define txGDI( command, dc )  ( ((dc) == txDC())? txUnlock ( (txLock(), (command)) ) : (command) )
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifndef FOR_DOXYGEN_ONLY
 
const int     _TX_CODEPAGE  =   1251;
 
#ifndef __CYGWIN__
const char    _TX_LOCALE[]  =  "Russian";
#else
const char    _TX_LOCALE[]  =  "ru_RU.CP1251";
#endif
 
const wchar_t _TX_WLOCALE[] = L"Russian_Russia.ACP";
 
#endif
 
int txSetLocale (int codepage = _TX_CODEPAGE, const char locale[] = _TX_LOCALE, const wchar_t wLocale[] = _TX_WLOCALE);
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Tune-up constants and variables
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
char _txLogName[MAX_PATH] = "";
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if  defined  (_TX_NOINIT)
 
    #undef     _TX_NOINIT
    #define    _TX_NOINIT                 1
 
#else
 
    #define    _TX_NOINIT                 0
 
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
int            _txConsoleMode             = SW_HIDE;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
int            _txWindowStyle             = WS_POPUP | WS_BORDER | WS_CAPTION | WS_SYSMENU;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
const char*    _txConsoleFont             = "Lucida Console";
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
unsigned       _txCursorBlinkInterval     = 500;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
unsigned       _txWindowUpdateInterval    = 25;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifdef FOR_DOXYGEN_ONLY
#define       TX_USE_SFML
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if !defined (TX_TRACE)
    const int  _TX_TIMEOUT                = 1000
 
#else
    const int  _TX_TIMEOUT                = 5000
 
#endif
 
#if  defined  (_TX_USE_DEVPARTNER)
    * 10
#endif
    ;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
bool (*_txSwapBuffers) (HDC dest, int xDest, int yDest, int wDest, int hDest,
                        HDC src,  int xSrc,  int ySrc,  int wSrc,  int hSrc, DWORD rOp) = NULL;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
const unsigned _TX_BUFSIZE                =  1024,
               _TX_BIGBUFSIZE             = _TX_BUFSIZE *  2,  
               _TX_HUGEBUFSIZE            = _TX_BUFSIZE * 20,  
 
               _TX_STACKSIZE              = 64 * 1024;         
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if !defined (_TX_EXCEPTIONS_LIMIT)
    #define   _TX_EXCEPTIONS_LIMIT        16
#endif
 
#if !defined (_TX_FATAL_EXCEPTIONS_LIMIT)
    #define   _TX_FATAL_EXCEPTIONS_LIMIT  16                   
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifdef FOR_DOXYGEN_ONLY
#define       _TX_FULL_STACKTRACE
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if !defined  (_TX_WAITABLE_PARENTS)
    #define    _TX_WAITABLE_PARENTS       "Winpty-agent.exe:Clion.exe, "            /* 0: CLion32       */ \
                                          "Winpty-agent.exe:Clion64.exe, "          /* 1: CLion64       */ \
                                          "starter.exe:eclipse.exe, "               /* 2: Eclipse 4     */ \
                                          "starter.exe:javaw.exe, "                 /* 3: Eclipse 3     */ \
                                          "cmd.exe:devenv.exe, "                    /* 4: MSVS 2003+    */ \
                                          "VSDebugConsole.exe:devenv.exe, "         /* 5: MSVS 2019     */ \
                                          "consolepauser.exe:devcpp.exe, "          /* 6: Dev-Cpp       */ \
                                          "cb_console_runner.exe:codeblocks.exe"    /* 7: CodeBlocks 8+ */
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#if !defined (_TX_ALLOW_KILL_PARENT)            // DISCLAIMER: ß íå ïðèçûâàþ ê óáèéñòâó ðîäèòåëåé.
    #define   _TX_ALLOW_KILL_PARENT       true  //             Ýòî òåõíè÷åñêèé òåðìèí.
#endif                                          //             ã_äàì þðèñòàì ïðèâåò.
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
int            _txWatchdogTimeout         = 10*_TX_TIMEOUT;
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Internal diagnostics
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifdef FOR_DOXYGEN_ONLY
#define _TX_ALLOW_TRACE
#endif
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifdef FOR_DOXYGEN_ONLY
#define       TX_TRACE
#endif
 
#if !defined (TX_TRACE)
    #define   TX_TRACE  { if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__); }
#endif
 
void _txTrace (const char file[], int line, const char func[], const char msg[] = NULL, ...);
 
//{----------------------------------------------------------------------------------------------------------------
    #ifndef FOR_DOXYGEN_ONLY
 
struct _txLoc
    {
    const char*   func;
    const char*   file;
    int           line;
 
    int           inTX;   // We are inside one of TXLib functions
    int           trace;  // Internal TX trace level, when enabled by _TX_ALLOW_TRACE
 
    const _txLoc* prev;   // Caller's location
 
    static _txLoc _tx_thread Cur;
    };
 
struct _txFuncEntry
    {
    typedef _txFuncEntry this_t;
 
    _txLoc loc;
 
    _txFuncEntry() : loc (_txLoc::Cur) { _txLoc::Cur.inTX++; _txLoc::Cur.prev = &loc; }
    void restore()                     { _txLoc::Cur = loc;                           }
   ~_txFuncEntry()                     { restore();                                   }
 
    private:
            _txFuncEntry (const this_t&) _tx_delete;
    this_t& operator =   (const this_t&) _tx_delete;
    };
 
#if defined (_GCC_VER)
 
    inline void __txLocCurSet (const char* _file, int _line, const char* _func)
        { _txLoc::Cur.file = _file; _txLoc::Cur.line = _line; _txLoc::Cur.func = _func; }
 
#else
 
    #define __txLocCurSet( _file, _line, _func ) \
        ( _txLoc::Cur.file = (_file), _txLoc::Cur.line = (_line), _txLoc::Cur.func = (_func) )
 
#endif
 
#define _txLocCurSet()     __txLocCurSet (__FILE__, __LINE__, __TX_FUNCTION__)
 
#define _txLocLvlSet(lvl)  { _txLoc::Cur.trace = (lvl); }
 
//{----------------------------------------------------------------------------------------------------------------
 
#if defined ($0)
    #undef   $0
    #endif
 
#if defined ($1)
    #undef   $1
    #endif
 
#if defined ($2)
    #undef   $2
    #endif
 
#if defined ($3)
    #undef   $3
    #endif
 
#if defined ($4)
    #undef   $4
    #endif
 
#if defined ($5)
    #undef   $5
    #endif
 
#if defined ($6)
    #undef   $6
    #endif
 
#if defined ($7)
    #undef   $7
    #endif
 
#if defined ($8)
    #undef   $8
    #endif
 
#if defined ($9)
    #undef   $9
    #endif
 
#if defined ($)
    #undef   $
    #endif
 
#if defined ($$)
    #undef   $$
    #endif
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_TX_ALLOW_TRACE)
 
    #define _txEntry(lvl)  _txFuncEntry __txFuncEntry; { if (lvl) _txLocLvlSet (lvl);    $;          }
 
    #define  $           { _txLocCurSet(); if (_txLoc::Cur.trace <= _TX_ALLOW_TRACE+0) { TX_TRACE; } }
 
    #define  $$          { __txFuncEntry.restore();                                                  }
 
#elif defined (_DEBUG)
 
    #define _txEntry(lvl)  _txFuncEntry __txFuncEntry; {                                 $;          }
 
    #define  $           { _txLocCurSet();                                                           }
 
    #define  $$          { __txFuncEntry.restore();                                                  }
 
#else
 
    #define _txEntry(lvl)  ;
    #define  $             ;
    #define  $$            ;
 
#endif
 
//{----------------------------------------------------------------------------------------------------------------
 
#define      $0            _txEntry (0)  // (Log level unchanged)
#define      $1            _txEntry (1)  // Regular functions
#define      $2            _txEntry (2)  // Resvd
#define      $3            _txEntry (3)  // Init/Cleanup
#define      $4            _txEntry (4)  // Init/Cleanup, misc functions
#define      $5            _txEntry (5)  // Error handling, entry points
#define      $6            _txEntry (6)  // Error handling, main part
#define      $7            _txEntry (7)  // Error handling, misc functions
#define      $8            _txEntry (8)  // Canvas worker thread
#define      $9            _txEntry (9)  // Resvd
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
    #endif // FOR_DOXYGEN_ONLY
//}----------------------------------------------------------------------------------------------------------------
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Sweet critical section blocking: txAutoLock class
//=================================================================================================================
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
extern CRITICAL_SECTION _txCanvas_LockBackBuf;
 
class txAutoLock
    {
    typedef txAutoLock this_t;
 
    public:
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    explicit txAutoLock (CRITICAL_SECTION* cs, bool mandatory = true) :
        cs_ (cs)
        {
$1      if (!cs_) return;
 
        if (mandatory) {$    EnterCriticalSection (cs_);                   }
        else           {$ TryEnterCriticalSection (cs_)? 0 : (cs_ = NULL); }
        }
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    explicit txAutoLock (bool mandatory = true) :
        cs_ (NULL)
        {
$1      new (this) txAutoLock (&_txCanvas_LockBackBuf, mandatory);
        }
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
   ~txAutoLock()
        {
$1      if (!cs_) return;
$       LeaveCriticalSection (cs_); cs_ = NULL;
        }
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    operator bool () const
        {
$1      return (cs_ != NULL);
        }
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
//  private:
    CRITICAL_SECTION* cs_;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    private:
            txAutoLock (const this_t&) _tx_delete;
    this_t& operator = (const this_t&) _tx_delete;
 
 
    };
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Dialogs: txDialog class
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
struct txDialog
    {
    typedef txDialog this_t;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    public:
    enum CONTROL
        {
        DIALOG    = (int) 0x00000000,            
        BUTTON    = (int) 0xFFFF0080,            
        EDIT      = (int) 0xFFFF0081,            
        STATIC    = (int) 0xFFFF0082,            
        LISTBOX   = (int) 0xFFFF0083,            
        SCROLLBAR = (int) 0xFFFF0084,            
        COMBOBOX  = (int) 0xFFFF0085,            
        END       = (int) 0x00000000             
        };
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    public:
    struct Layout
        {
        CONTROL     wndclass;                    
        const char* caption;                     
        WORD        id;                          
        short        x;                          
        short        y;                          
        short       sx;                          
        short       sy;                          
        DWORD       style;                       
 
        const char* font;                        
        WORD        fontsize;                    
        };
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    public:
    txDialog();
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    explicit txDialog (const Layout* layout);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    virtual ~txDialog() {};
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    const Layout* setLayout (const Layout *layout);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    virtual int dialogProc (HWND _wnd, UINT _msg, WPARAM _wParam, LPARAM _lParam);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    intptr_t dialogBox (const Layout* layout = NULL, size_t bufsize = 0);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    intptr_t dialogBox (WORD resource);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    private:
            txDialog   (const this_t&) _tx_delete;
    this_t& operator = (const this_t&) _tx_delete;
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    protected:
    static intptr_t CALLBACK DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam);
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
    private:
    const Layout* layout_;
    };
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Dialogs: Message Map macros
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define TX_BEGIN_MESSAGE_MAP()                                                                 \
    virtual int dialogProc (HWND _wnd, UINT _msg, WPARAM _wParam, LPARAM _lParam) _tx_override \
        {                                                                                      \
        int _result = txDialog::dialogProc (_wnd, _msg, _wParam, _lParam); (void) _result;     \
                                                                                               \
        switch (_msg)                                                                          \
            {                                                                                  \
            case WM_NULL:
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define TX_HANDLE( id )                                                                        \
            break;                                                                             \
            case (id):
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define TX_COMMAND_MAP                                                                         \
            default: break;                                                                    \
            }                                                                                  \
                                                                                               \
        if (_msg == WM_COMMAND) switch (LOWORD (_wParam))                                      \
            {                                                                                  \
            case 0:
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#define TX_END_MESSAGE_MAP                                                                     \
            default: break;                                                                    \
            }                                                                                  \
                                                                                               \
        return FALSE;                                                                          \
        }
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Dialogs: txDialog example: txInputBox()
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
const char* txInputBox (const char* text = NULL, const char* caption = NULL, const char* input = NULL) tx_nodiscard;
 
const char* txInputBox (const char* text, const char* caption, const char* input)
    {
    //-------------------------------------------------------------------------------------------------------------
    // Åñëè íå óêàçàíû ïàðàìåòðû, ïðèõîäèòñÿ èñïîëüçîâàòü õîòü êàêèå-òî íàäïèñè.
    // txGetModuleFileName() -- èìÿ EXE-ôàéëà, íà ñëó÷àé, åñëè êîå-êòî ïîëåíèëñÿ çàäàòü íàçâàíèå.
    //-------------------------------------------------------------------------------------------------------------
 
    if (!text)    text    = "Ââåäèòå ñòðîêó:";
    if (!caption) caption = txGetModuleFileName (false);
    if (!input)   input   = "";
 
    //-------------------------------------------------------------------------------------------------------------
    // Èäåíòèôèêàòîðû ýëåìåíòîâ äèàëîãà. Îíè òðåáóþòñÿ â GetDlgItemText().
    // Åñëè äèàëîã ñòðîèòñÿ íå âðó÷íóþ, à ðåäàêòîðîì ðåñóðñîâ, òî îíè çàäàþòñÿ â íåì àâòîìàòè÷åñêè.
    // Ó íàñ æå òóò -- õàðäêîð ñòàéë, ê ñîæàëåíèþ. Ïðè÷èíà â òîì, ÷òî ó ðàçíûõ ñðåä ïðîãðàììèðîâàíèÿ ðàçíûå ðåäàêòîðû    // ðåñóðñîâ è ñèñòåìû ñáîðêè. Ïîýòîìó äëÿ íåçàâèñèìîñòè îò íèõ âñå áóäåò ñòðîèòüñÿ íà ýòàïå âûïîëíåíèÿ,
    // äèíàìè÷åñêè. Âû åùå ãëÿíüòå, êàê ýòî ðåàëèçîâàíî â txDialog::dialogBox() è ôóíêöèÿõ _tx_DLGTEMPLATE_()... Î_î
    //-------------------------------------------------------------------------------------------------------------

    #define ID_TEXT_  101
    #define ID_INPUT_ 102

    //-------------------------------------------------------------------------------------------------------------
    // Çàäàíèå ìàêåòà (âèäà) äèàëîãà â âèäå ìàññèâà ñòðóêòóð.
    // Ñ ïîìîùüþ îñîáîãî ïîðÿäêà ïîëåé â ñòðóêòóðå txDialog::Layout è êîíñòàíò èç êëàññà txDialog ýòîò ìàññèâ
    // ñòàíîâèòñÿ ïîõîæ íà îïèñàíèå ðåñóðñà äèàëîãà â .rc-ôàéëå.
    // Ñì. îïèñàíèå ñèíòàêñèñà rc-ôàéëà â äîêóìåíòàöèè ïî Win32 (MSDN, http://msdn.com).
    //-------------------------------------------------------------------------------------------------------------

    txDialog::Layout layout[] =

    //----------------------+----------+-----------+-----------------+---------------------------------------------
    //     Òèï ýëåìåíòà     | Èìÿ      | Èäåíòè-   |   Êîîðäèíàòû    | Ôëàãè ýëåìåíòîâ
    //     äèàëîãà          | ýëåìåíòà | ôèêàòîð   |-----------------| (ñì. îïèñàíèå ýëåìåíòîâ
    //                      |          | ýëåìåíòà  | X | Y |Øèð.|Âûñ.| îêîí äèàëîãà â MSDN)
    //----------------------+----------+-----------+---+---+----+----+---------------------------------------------
    //                      |          |           |   |   |    |    |
        {{ txDialog::DIALOG,  caption,   0,           0,  0, 240,  85                                                    },
         { txDialog::STATIC,  text,      ID_TEXT_,   10, 10, 150,  40, SS_LEFT                                           },
         { txDialog::EDIT,    input,     ID_INPUT_,  10, 60, 220,  15, ES_LEFT | WS_BORDER | ES_AUTOHSCROLL | WS_TABSTOP },
         { txDialog::BUTTON,  "&OK",     IDOK,      180, 10,  50,  15, BS_DEFPUSHBUTTON                     | WS_TABSTOP },
         { txDialog::BUTTON,  "&Cancel", IDCANCEL,  180, 30,  50,  15, BS_PUSHBUTTON                        | WS_TABSTOP },
         { txDialog::END                                                                                                 }};

    //-------------------------------------------------------------------------------------------------------------
    // Êëàññ äèàëîãà äëÿ InputBox. Âíóòðåííèé, ò.ê. çà÷åì åìó áûòü âíåøíèì.
    // Íóæåí â îñíîâíîì äëÿ çàäàíèÿ ñòðîêè ââîäà (str) è îêîííîé ôóíêöèè äèàëîãîâîãî îêíà, òðåáóåìîé Win32 (îíà
    // ïîñòðîåíà ìàêðîñàìè TX_BEGIN_MESSAGE_MAP è äðóãèìè). Ìîæíî íå äåëàòü âíóòðåííåãî êëàññà, íî òîãäà îêîííóþ
    // ôóíêöèþ ïðèäåòñÿ ïèñàòü â ãëîáàëüíîé îáëàñòè âèäèìîñòè, è str îáúÿâëÿòü ãëîáàëüíî òîæå (èëè ïåðåäàâàòü åå
    // àäðåñ ÷åðåç DialogBoxParam è çàïèñûâàòü åãî â êëàññ âî âðåìÿ îáðàáîòêè WM_INITDIALOG).
    //-------------------------------------------------------------------------------------------------------------
    struct inputDlg : txDialog
        {
        char str [1024];

        //---------------------------------------------------------------------------------------------------------

        inputDlg() :
            str()
            {}

        //---------------------------------------------------------------------------------------------------------

        TX_BEGIN_MESSAGE_MAP()    // Êàðòà ñîîáùåíèé (íà ñàìîì äåëå ýòî íà÷àëî îêîííîé ôóíêöèè).

            TX_COMMAND_MAP        // Çäåñü îáðàáàòûâàþòñÿ WM_COMMAND (íà ñàìîì äåëå ýòî îïåðàòîð switch).

                //-------------------------------------------------------------------------------------------------
                // Ïðè íàæàòèè êíîïêè OK êîïèðóåì ñòðîêó èç ïîëÿ ââîäà â íàøó ïåðåìåííóþ str, ò.ê. ïîñëå çàêðûòèÿ
                // äèàëîãà ñòðîêà ââîäà óìðåò è òåêñò óæå èç íåå ïîëó÷èòü.
                // Ýòîò ìàêðîñ íà ñàìîì äåëå ïðåâðàùàåòñÿ â case èç îïåðàòîðà switch.
                // _wnd -- ýòî ïàðàìåòð îêîííîé ôóíêöèè, ñì. îïðåäåëåíèå ìàêðîñà TX_BEGIN_MESSAGE_MAP().
                //-------------------------------------------------------------------------------------------------

                TX_HANDLE (IDOK) GetDlgItemText (_wnd, ID_INPUT_, str, sizeof (str) - 1);

        TX_END_MESSAGE_MAP

        //---------------------------------------------------------------------------------------------------------
        // Êîíåö âíóòðåííåãî êëàññà äèàëîãà
        //---------------------------------------------------------------------------------------------------------
        };

    //-------------------------------------------------------------------------------------------------------------
    // Óáèðàåì äåôàéíû, ÷òîáû ïîòîì íå ìåøàëè.
    // Îò ýòîãî îíè ïîëó÷àþòñÿ "ëîêàëüíîãî äåéñòâèÿ", êàê áóäòî ó íèõ áûëà áû îáëàñòü âèäèìîñòè -- ôóíêöèÿ. Íà ñàìîì
    // äåëå ýòî ñäåëàíî âðó÷íóþ ÷åðåç #undef. ×òîáû ïîä÷åðêíóòü èõ ëîêàëüíóþ ïðèðîäó, ó íèõ èìåíà çàêàí÷èâàþòñÿ íà _.
    // Òàêèå äåôàéíû ïîòîì íå ïåðåêîñÿ÷àò âåñü êîä ïîñëå òîãî êàê, ôàêòè÷åñêè, ñòàëè óæå íå íóæíû.
    //-------------------------------------------------------------------------------------------------------------

    #undef ID_TEXT_
    #undef ID_INPUT_

    //-------------------------------------------------------------------------------------------------------------
    // Ýòî ñòàòè÷åñêèé îáúåêò, ïîòîìó ÷òî ñòðîêà â íåì äîëæíà æèòü ïîñëå çàâåðøåíèÿ ôóíêöèè.
    //-------------------------------------------------------------------------------------------------------------

    static inputDlg dlg;

    //-------------------------------------------------------------------------------------------------------------
    // Ïåðåäàåì layout è çàïóñêàåì îêíî äèàëîãà
    //-------------------------------------------------------------------------------------------------------------

    dlg.dialogBox (layout);

    //-------------------------------------------------------------------------------------------------------------
    // Âîçâðàùàåì àäðåñ ñòðîêè èç ñòàòè÷åñêîãî îáúåêòà. Òàê ìîæíî äåëàòü, ïîòîìó ÷òî ñòàòè÷åñêèé îáúåêò íå óìðåò
    // ïðè âûõîäå èç ôóíêöèè è ñòðîêà â íåì, ñîîòâåòñòâåííî, òîæå. Àäðåñ íåñòàòè÷åñêèõ ïåðåìåííûõ ïåðåäàâàòü
    // ñèíòàêñè÷åñêè ìîæíî, íî âåäåò ê ñåðüåçíûì îøèáêàì.
    //-------------------------------------------------------------------------------------------------------------

    return dlg.str;
    }

//! @}
//}
//=================================================================================================================

//}
//=================================================================================================================

//=================================================================================================================
//{          TXLIB IMPLEMENTATION
//           Ðåàëèçàöèÿ ôóíêöèé áèáëèîòåêè
//=================================================================================================================
//! @cond INTERNAL

//=================================================================================================================
//{          DLL functions import, missing types definitions
//! @name    Èìïîðò âíåøíèõ áèáëèîòåê, îïðåäåëåíèå íåäîñòàþùèõ òèïîâ
//=================================================================================================================
//! @{

namespace Win32 {

//-----------------------------------------------------------------------------------------------------------------
//{ Some of structs, consts and interfaces aren't defined in MinGW some early headers.
//  Copied from Windows SDK 7.0a.
//-----------------------------------------------------------------------------------------------------------------

#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                             0x01
#endif

#ifndef SMTO_ERRORONEXIT
#define SMTO_ERRORONEXIT                         0x0020
#endif

#ifndef NT_CONSOLE_PROPS_SIG
#define NT_CONSOLE_PROPS_SIG                     0xA0000002
#endif

#ifndef NIIF_INFO
#define NIIF_INFO                                0x00000001
#define NIIF_WARNING                             0x00000002
#define NIIF_ERROR                               0x00000003
#endif

#ifndef NIF_INFO
#define NIF_STATE                                0x00000008
#define NIF_INFO                                 0x00000010
#endif

#ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
#define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS   0x00000004
#endif

#ifndef SYMOPT_CASE_INSENSITIVE
#define SYMOPT_CASE_INSENSITIVE                  0x00000001
#define SYMOPT_UNDNAME                           0x00000002
#define SYMOPT_DEFERRED_LOADS                    0x00000004
#define SYMOPT_NO_CPP                            0x00000008
#define SYMOPT_LOAD_LINES                        0x00000010
#define SYMOPT_OMAP_FIND_NEAREST                 0x00000020
#define SYMOPT_LOAD_ANYTHING                     0x00000040
#define SYMOPT_IGNORE_CVREC                      0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS              0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS              0x00000200
#define SYMOPT_EXACT_SYMBOLS                     0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS            0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH                 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES             0x00002000
#define SYMOPT_PUBLICS_ONLY                      0x00004000
#define SYMOPT_NO_PUBLICS                        0x00008000
#define SYMOPT_AUTO_PUBLICS                      0x00010000
#define SYMOPT_NO_IMAGE_SEARCH                   0x00020000
#define SYMOPT_SECURE                            0x00040000
#define SYMOPT_NO_PROMPTS                        0x00080000
#define SYMOPT_ALLOW_ZERO_ADDRESS                0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT         0x02000000
#define SYMOPT_FAVOR_COMPRESSED                  0x00800000
#define SYMOPT_FLAT_DIRECTORY                    0x00400000
#define SYMOPT_IGNORE_IMAGEDIR                   0x00200000
#define SYMOPT_OVERWRITE                         0x00100000
#define SYMOPT_DEBUG                             0x80000000
#endif

// SEH exception codes. For GCC, see http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 64-66.

#ifndef STATUS_POSSIBLE_DEADLOCK
#define STATUS_POSSIBLE_DEADLOCK                 0xC0000194
#endif

#ifndef STATUS_FLOAT_MULTIPLE_FAULTS
#define STATUS_FLOAT_MULTIPLE_FAULTS             0xC00002B4
#endif

#ifndef STATUS_STACK_BUFFER_OVERRUN
#define STATUS_STACK_BUFFER_OVERRUN              0xC0000409
#endif

#ifndef STATUS_ASSERTION_FAILURE
#define STATUS_ASSERTION_FAILURE                 0xC0000420
#endif

#ifndef STATUS_WX86_BREAKPOINT
#define STATUS_WX86_BREAKPOINT                   0x4000001F
#endif

#ifndef DBG_PRINTEXCEPTION_C
#define DBG_PRINTEXCEPTION_C                     0x40010006  // OutputDebugStringA() call
#endif

#ifndef DBG_PRINTEXCEPTION_WIDE_C
#define DBG_PRINTEXCEPTION_WIDE_C                0x4001000A  // OutputDebugStringW() call
#endif

#ifndef DBG_THREAD_NAME
#define DBG_THREAD_NAME                          0x406D1388
#endif

#define EXCEPTION_CPP_MSC                        0xE06D7363  // '?msc'
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1       0x19930520  // '?msc' version magic, see ehdata.h
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2       0x19930521  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3       0x19930522  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1  0x01994000  // '?msc' version magic

#define EXCEPTION_CPP_GCC                        0x20474343  // ' GCC'
#define EXCEPTION_CPP_GCC_UNWIND                 0x21474343  // '!GCC'
#define EXCEPTION_CPP_GCC_FORCED                 0x22474343  // '"GCC'

#define EXCEPTION_CLR_FAILURE                    0xE0434f4D  // 'àCOM'

#define EXCEPTION_CPP_BORLAND_BUILDER            0x0EEDFAE6  // Should never occur here
#define EXCEPTION_CPP_BORLAND_DELPHI             0x0EEDFADE  // Should never occur here

#pragma pack (push, 1)

struct CONSOLE_CURSOR_INFO
    {
    DWORD dwSize;
    BOOL bVisible;
    };

struct CONSOLE_FONT_INFO
    {
    DWORD nFont;
    COORD dwFontSize;
    };

struct CONSOLE_FONT_INFOEX
    {
    ULONG cbSize;
    DWORD nFont;
    COORD dwFontSize;
    UINT  FontFamily;
    UINT  FontWeight;
    WCHAR FaceName[LF_FACESIZE];
    };

struct DATABLOCK_HEADER
    {
    DWORD cbSize;
    DWORD dwSignature;
    };

struct NT_CONSOLE_PROPS
    {
    DATABLOCK_HEADER dbh;

    WORD  wFillAttribute;
    WORD  wPopupFillAttribute;
    COORD dwScreenBufferSize;
    COORD dwWindowSize;
    COORD dwWindowOrigin;
    DWORD nFont;
    DWORD nInputBufferSize;
    COORD dwFontSize;
    UINT  uFontFamily;
    UINT  uFontWeight;
    WCHAR FaceName[LF_FACESIZE];
    UINT  uCursorSize;
    BOOL  bFullScreen;
    BOOL  bQuickEdit;
    BOOL  bInsertMode;
    BOOL  bAutoPosition;
    UINT  uHistoryBufferSize;
    UINT  uNumberOfHistoryBuffers;
    BOOL  bHistoryNoDup;

    COLORREF ColorTable[16];
    };

#pragma pack (pop)

#undef  INTERFACE
#define INTERFACE IShellLinkDataList

DECLARE_INTERFACE_ (IShellLinkDataList, IUnknown)
    {
    // *** IUnknown methods ***
    STDMETHOD (QueryInterface)  (THIS_ REFIID iid, void** value)    _tx_override PURE;
    STDMETHOD_(ULONG, AddRef)   (THIS)                              _tx_override PURE;
    STDMETHOD_(ULONG, Release)  (THIS)                              _tx_override PURE;

    // *** IShellLinkDataList methods ***
    STDMETHOD (AddDataBlock)    (THIS_ void* dataBlock)             PURE;
    STDMETHOD (CopyDataBlock)   (THIS_ DWORD sig, void** dataBlock) PURE;
    STDMETHOD (RemoveDataBlock) (THIS_ DWORD sig)                   PURE;
    STDMETHOD (GetFlags)        (THIS_ DWORD* flags)                PURE;
    STDMETHOD (SetFlags)        (THIS_ DWORD  flags)                PURE;

    protected:
    virtual ~IShellLinkDataList();
    };

const GUID IID_IShellLink         = {0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID IID_IShellLinkDataList = {0x45e2b4ae, 0xb1c3, 0x11d0, {0xb9,0x2f,0x00,0xa0,0xc9,0x03,0x12,0xe1}};
const GUID IID_IPersistFile       = {0x0000010b, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};

const GUID CLSID_SpVoice          = {0x96749377, 0x3391, 0x11d2, {0x9e,0xe3,0x00,0xc0,0x4f,0x79,0x73,0x96}};
const GUID IID_ISpVoice           = {0x6c44df74, 0x72b9, 0x4992, {0xa1,0xec,0xef,0x99,0x6e,0x04,0x22,0xd4}};

#undef  INTERFACE

typedef DWORD     NTSTATUS;
typedef ULONG_PTR KAFFINITY;
typedef LONG      KPRIORITY;

struct UNICODE_STRING
    {
    USHORT Length;
    USHORT MaximumLength;
    WCHAR* Buffer;
    };

struct RTL_USER_PROCESS_PARAMETERS
    {
    BYTE  Reserved1[16];
    void* Reserved2[10];
    UNICODE_STRING ImagePathName;
    UNICODE_STRING CommandLine;
    };

struct PEB
    {
    BYTE  Reserved1[2];
    BYTE  BeingDebugged;
    BYTE  Reserved2[1];
    void* Reserved3[2];
    void* Ldr;
    RTL_USER_PROCESS_PARAMETERS* ProcessParameters;
    void* Reserved4[3];
    void* AtlThunkSListPtr;
    void* Reserved5;
    ULONG Reserved6;
    void* Reserved7;
    ULONG Reserved8;
    ULONG AtlThunkSListPtr32;
    void* Reserved9[45];
    BYTE  Reserved10[96];
    void* PostProcessInitRoutine;
    BYTE  Reserved11[128];
    void* Reserved12[1];
    ULONG SessionId;
    };

struct PROCESS_BASIC_INFORMATION
    {
    NTSTATUS  ExitStatus;
    PEB*      PebBaseAddress;
    KAFFINITY AffinityMask;
    KPRIORITY BasePriority;
    ULONG_PTR UniqueProcessId;
    ULONG_PTR InheritedFromUniqueProcessId;
    };

enum ADDRESS_MODE
    {
    AddrMode1616,
    AddrMode1632,
    AddrModeReal,
    AddrModeFlat
    };

struct ADDRESS64
    {
    DWORD64      Offset;
    WORD         Segment;
    ADDRESS_MODE Mode;
    };

struct KDHELP64
    {
    DWORD64 Thread;
    DWORD   ThCallbackStack;
    DWORD   ThCallbackBStore;
    DWORD   NextCallback;
    DWORD   FramePointer;
    DWORD64 KiCallUserMode;
    DWORD64 KeUserCallbackDispatcher;
    DWORD64 SystemRangeStart;
    DWORD64 KiUserExceptionDispatcher;
    DWORD64 StackBase;
    DWORD64 StackLimit;
    DWORD64 Reserved[5];
    };

struct STACKFRAME64
    {
    ADDRESS64 AddrPC;
    ADDRESS64 AddrReturn;
    ADDRESS64 AddrFrame;
    ADDRESS64 AddrStack;
    ADDRESS64 AddrBStore;
    PVOID     FuncTableEntry;
    DWORD64   Params[4];
    BOOL      Far;
    BOOL      Virtual;
    DWORD64   Reserved[3];
    KDHELP64  KdHelp;
    };

struct WOW64_FLOATING_SAVE_AREA
    {
    DWORD ControlWord;
    DWORD StatusWord;
    DWORD TagWord;
    DWORD ErrorOffset;
    DWORD ErrorSelector;
    DWORD DataOffset;
    DWORD DataSelector;
    BYTE  RegisterArea[80];
    DWORD Cr0NpxState;
    };

#pragma pack (push, 4)

struct WOW64_CONTEXT
    {
    DWORD ContextFlags;

    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;

    WOW64_FLOATING_SAVE_AREA FloatSave;

    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;

    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;

    DWORD Ebp;
    DWORD Eip;
    DWORD SegCs;
    DWORD EFlags;
    DWORD Esp;
    DWORD SegSs;

    BYTE  ExtendedRegisters[512];
    };

#pragma pack (pop)

struct SYMBOL_INFO
    {
    ULONG   SizeOfStruct;
    ULONG   TypeIndex;
    ULONG64 Reserved[2];
    ULONG   info;
    ULONG   Size;
    ULONG64 ModBase;
    ULONG   Flags;
    ULONG64 Value;
    ULONG64 Address;
    ULONG   Register;
    ULONG   Scope;
    ULONG   Tag;
    ULONG   NameLen;
    ULONG   MaxNameLen;
    CHAR    Name[1];
    };

struct IMAGEHLP_LINE64
    {
    DWORD   SizeOfStruct;
    PVOID   Key;
    DWORD   LineNumber;
    PCHAR   FileName;
    DWORD64 Address;
    };

typedef bool    (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)   (HANDLE process, DWORD64 baseAddress, void* buffer, DWORD size, DWORD* bytesRead);
typedef void*   (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64) (HANDLE process, DWORD64 baseAddress);
typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)       (HANDLE process, DWORD64 address);
typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)     (HANDLE process, HANDLE thread, ADDRESS64* address);

typedef void (*unexpected_handler)();

#pragma pack (push, 4)

struct MINIDUMP_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    };

struct MINIDUMP_THREAD_EX_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    ULONG64  BackingStoreBase;
    ULONG64  BackingStoreEnd;
    };

struct MINIDUMP_MODULE_CALLBACK
    {
    wchar_t* FullPath;
    ULONG64  BaseOfImage;
    ULONG    SizeOfImage;
    ULONG    CheckSum;
    ULONG    TimeDateStamp;
    VS_FIXEDFILEINFO VersionInfo;
    void*    CvRecord;
    ULONG    SizeOfCvRecord;
    PVOID    MiscRecord;
    ULONG    SizeOfMiscRecord;
    };

struct MINIDUMP_INCLUDE_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    };

struct MINIDUMP_INCLUDE_MODULE_CALLBACK
    {
    ULONG64  BaseOfImage;
    };

struct MINIDUMP_MEMORY_INFO
    {
    ULONG64  BaseAddress;
    ULONG64  AllocationBase;
    ULONG32  AllocationProtect;
    ULONG32  __alignment1;
    ULONG64  RegionSize;
    ULONG32  State;
    ULONG32  Protect;
    ULONG32  Type;
    ULONG32  __alignment2;
    };

struct MINIDUMP_USER_STREAM
    {
    ULONG32  Type;
    ULONG    BufferSize;
    PVOID    Buffer;
    };

struct MINIDUMP_USER_STREAM_INFORMATION
    {
    ULONG                 UserStreamCount;
    MINIDUMP_USER_STREAM* UserStreamArray;
    };

struct MINIDUMP_CALLBACK_INPUT
    {
    ULONG    ProcessId;
    HANDLE   ProcessHandle;
    ULONG    CallbackType;

    union
        {
        MINIDUMP_THREAD_CALLBACK         Thread;
        MINIDUMP_THREAD_EX_CALLBACK      ThreadEx;
        MINIDUMP_MODULE_CALLBACK         Module;
        MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
        MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
        };
    };

struct MINIDUMP_CALLBACK_OUTPUT
    {
    union
        {
        ULONG ModuleWriteFlags;
        ULONG ThreadWriteFlags;
        ULONG SecondaryFlags;

        struct
            {
            ULONG64  MemoryBase;
            ULONG    MemorySize;
            };

        struct
            {
            unsigned CheckCancel;
            unsigned Cancel;
            };

        HANDLE Handle;
        };

    struct
        {
        MINIDUMP_MEMORY_INFO VmRegion;
        unsigned             Continue;
        };

    HRESULT Status;
    };

struct MINIDUMP_EXCEPTION_INFORMATION
    {
    DWORD               ThreadId;
    EXCEPTION_POINTERS* ExceptionPointers;
    unsigned            ClientPointers;
    };

typedef int (WINAPI* MINIDUMP_CALLBACK_ROUTINE) (void* param, MINIDUMP_CALLBACK_INPUT* input, MINIDUMP_CALLBACK_OUTPUT* output);

struct MINIDUMP_CALLBACK_INFORMATION
    {
    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
    void*                     CallbackParam;
    };

enum MINIDUMP_TYPE
    {
    MiniDumpNormal                         = 0x00000000,
    MiniDumpWithDataSegs                   = 0x00000001,
    MiniDumpWithFullMemory                 = 0x00000002,
    MiniDumpWithHandleData                 = 0x00000004,
    MiniDumpFilterMemory                   = 0x00000008,
    MiniDumpScanMemory                     = 0x00000010,
    MiniDumpWithUnloadedModules            = 0x00000020,
    MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
    MiniDumpFilterModulePaths              = 0x00000080,
    MiniDumpWithProcessThreadData          = 0x00000100,
    MiniDumpWithPrivateReadWriteMemory     = 0x00000200,
    MiniDumpWithoutOptionalData            = 0x00000400,
    MiniDumpWithFullMemoryInfo             = 0x00000800,
    MiniDumpWithThreadInfo                 = 0x00001000,
    MiniDumpWithCodeSegs                   = 0x00002000,
    MiniDumpWithoutAuxiliaryState          = 0x00004000,
    MiniDumpWithFullAuxiliaryState         = 0x00008000,
    MiniDumpWithPrivateWriteCopyMemory     = 0x00010000,
    MiniDumpIgnoreInaccessibleMemory       = 0x00020000,
    MiniDumpWithTokenInformation           = 0x00040000
    };

#pragma pack (pop)

#define FOREGROUND_BLACK         ( 0                                                         )
#define FOREGROUND_CYAN          ( FOREGROUND_BLUE       | FOREGROUND_GREEN                  )
#define FOREGROUND_MAGENTA       ( FOREGROUND_BLUE       | FOREGROUND_RED                    )
#define FOREGROUND_DARKYELLOW    ( FOREGROUND_GREEN      | FOREGROUND_RED                    )
#define FOREGROUND_LIGHTGRAY     ( FOREGROUND_BLUE       | FOREGROUND_GREEN | FOREGROUND_RED )
#define FOREGROUND_DARKGRAY      (                         FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTBLUE     ( FOREGROUND_BLUE       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTGREEN    ( FOREGROUND_GREEN      | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTCYAN     ( FOREGROUND_CYAN       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTRED      ( FOREGROUND_RED        | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTMAGENTA  ( FOREGROUND_MAGENTA    | FOREGROUND_INTENSITY              )
#define FOREGROUND_YELLOW        ( FOREGROUND_DARKYELLOW | FOREGROUND_INTENSITY              )
#define FOREGROUND_WHITE         ( FOREGROUND_LIGHTGRAY  | FOREGROUND_INTENSITY              )

#define BACKGROUND_BLACK         ( 0                                                         )
#define BACKGROUND_CYAN          ( BACKGROUND_BLUE       | BACKGROUND_GREEN                  )
#define BACKGROUND_MAGENTA       ( BACKGROUND_BLUE       | BACKGROUND_RED                    )
#define BACKGROUND_DARKYELLOW    ( BACKGROUND_GREEN      | BACKGROUND_RED                    )
#define BACKGROUND_GRAY          ( BACKGROUND_BLUE       | BACKGROUND_GREEN | BACKGROUND_RED )
#define BACKGROUND_DARKGRAY      (                         BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTBLUE     ( BACKGROUND_BLUE       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTGREEN    ( BACKGROUND_GREEN      | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTCYAN     ( BACKGROUND_CYAN       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTRED      ( BACKGROUND_RED        | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTMAGENTA  ( BACKGROUND_MAGENTA    | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTYELLOW   ( BACKGROUND_DARKYELLOW | BACKGROUND_INTENSITY              )
#define BACKGROUND_WHITE         ( BACKGROUND_DARKGRAY   | BACKGROUND_INTENSITY              )

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ There are copies of MSVC compiler built-in predefined definitions, which are wrong in 64-bit mode.
//  So we have to override them. See: http://stackoverflow.com/questions/39113168
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)
                                                    //  MS ABI C++ Exception Layout
namespace Win32 {                                   //  ---------------------------
                                                    //
#pragma pack (push, 4)                              //   EXCEPTION_RECORD:
                                                    //  +==================================================+
struct ThrowInfo                                    //  |...                                               |
    {                                               //  |NumberParameters:        3, 4 or more             |
    __int32 attributes;                             //  |ExceptionInformation[0]: MS signature 0x19930520  |
    __int32 pmfnUnwind;                             //  |ExceptionInformation[1]: object* thrown           |
    __int32 pForwardCompat;                         //  |ExceptionInformation[2]: ThrowInfo* --------------+---+
    __int32 pCatchableTypeArray;                    //  |ExceptionInformation[3]: ImageBase (if params > 3)|   |
    };                                              //  +==================================================+   |
                                                    //                                                         |
struct CatchableTypeArray                           //        ThrowInfo:                                       |
    {                                               //        +======================================+ <-------+
    __int32 nCatchableTypes;                        //        |   ...                                |
    __int32 arrayOfCatchableTypes[];                //  +-----+-- pCatchableTypeArray (ptr/RVA)      |
    };                                              //  |     +======================================+
                                                    //  |
struct CatchableType                                //  |     CatchableTypeArray:
    {                                               //  +---> +======================================+
    __int32 properties;                             //        |   ...                                |
    __int32 pType;                                  //  +-----+-- arrayOfCatchableTypes[0] (ptr/RVA) |
    __int32 thisDisplacement[3]; // struct _PMD     //  |     +======================================+
    __int32 sizeOrOffset;                           //  |
    __int32 copyFunction;                           //  |     CatchableType:
    };                                              //  +---> +====================+
                                                    //        | ...                |        std::type_info:
#pragma pack (pop)                                  //        | pType (ptr/RVA) ---+------> +==================+
                                                    //        | ...                |        |type_info data    |
} // namespace Win32                                //        +====================+        |...               |
                                                    //                                      +==================+
#endif

// Similar to __CxxDetectRethrow(), see C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\crtsrc\vcruntime\frame.cpp:

#define _TX_MSC__CXX_DETECT_RETHROW( exc )                                     \
    (                                                                          \
    (exc)                                          &&                          \
    (exc) -> ExceptionCode    == EXCEPTION_CPP_MSC &&                          \
    (exc) -> NumberParameters >= 3                 &&                          \
                                                                               \
    ((exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3) && \
                                                                               \
    (exc) -> ExceptionInformation[2] == 0                                      \
    )

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ The corresponding structures for GCC
//
//  From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/unwind-cxx.h
//  See:  http://mentorembedded.github.io/cxx-abi/abi-eh.html#cxx-abi
//-----------------------------------------------------------------------------------------------------------------

#if defined (_GCC_VER)
                                                    // GCC ABI C++ Exception layout. A/B are ExceptionInformation[0].
namespace ABI {                                     // --------------------------------------------------------------
                                                    //
struct __cxa_exception                              // Case A: "_Unwind_Exception* A" is undependent exception:
    {                                               // --------------------------------------------------------
    union {                                         //
        struct                                      //           __cxa_exception:           std::type_info:
            {                                       //       -*--+====================+     +==================+
            ::std::type_info* exceptionType;        //        ^  |exceptionType* -----+---->|type_info data    |
            void (*exceptionDestructor)(void*);     //        |  |...                 |     |...               |
            };                                      //       -1  |                    |     +==================+
        struct                                      //        |  |                    |
            {                                       // A >----|--+--------------------+
            __cxa_exception*  primaryException;     //     |  |  |unwindHeader        |
            void (*padding)();                      //    +1  |  |                    |
            };                                      //     |  |  |                    |
        };                                          //     V  |  |                    |
                                                    //    -*---  +====================+
    std::unexpected_handler   unexpectedHandler;    //           |object              |
    std::terminate_handler    terminateHandler;     //           +--------------------+
                                                    //
    __cxa_exception*          nextException;        // Case B: "_Unwind_Exception* B" is dependent exception
    int                       handlerCount;         // (unwindHeader.exception_class & 1 != 0):
    int                       handlerSwitchValue;   // -----------------------------------------------------
    const unsigned char*      actionRecord;         //
    const unsigned char*      languageSpecificData; //           __cxa_exception:               __cxa_exception:
    void*                     catchTemp;            //       -*--+====================+     -*--+=================+
    void*                     adjustedPtr;          //        ^  |primaryException* --+--    ^  |exceptionType*   |
                                                    //        |  |...                 |  \   |  |...              |
    _Unwind_Exception         unwindHeader;         //       -1  |                    |  |   |  |                 |
    };                                              //        |  |                    |  |   |  |                 |
                                                    // B >----|--+--------------------+  |  -1  +-----------------+
struct __cxa_eh_globals                             //     |  |  |unwindHeader        |  |   |  |unwindHeader     |
    {                                               //    +1  |  |                    |  |   |  |                 |
    __cxa_exception* caughtExceptions;              //     |  |  |                    |  |   |  |                 |
    unsigned int     uncaughtExceptions;            //     V  |  |                    |  \   |  |                 |
    };                                              //    -*---  +====================+   -->*--+=================+
                                                    //           |...                 |         |object           |
} // namespace ABI                                  //           .                    .         |                 |
                                                    //                                          +-----------------+

extern "C" ABI::__cxa_eh_globals* __cxa_get_globals();

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ Hand-made IAT.
//  Some IDEs don't link with these libs by default in console projects, so do sunrise by hand. :(
//-----------------------------------------------------------------------------------------------------------------

// Hand-made DLLIMPORT helpers

#define _TX_DLLIMPORT(     lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, true)

#define _TX_DLLIMPORT_OPT( lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, false)

#define _TX_DLLIMPORT_CRT( lib, retval, name, params ) \
     retval (      * name) params = (retval (      *) params) _txDllImport (lib ".dll", #name, false)

typedef void (*_tx_FARPROC)();

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required = true);

//-----------------------------------------------------------------------------------------------------------------

namespace Win32 {

_TX_DLLIMPORT     ("GDI32",    HDC,      CreateCompatibleDC,            (HDC dc));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateCompatibleBitmap,        (HDC dc, int width, int height));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetStockObject,                (int object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  SelectObject,                  (HDC dc, HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetCurrentObject,              (HDC dc, unsigned objectType));
_TX_DLLIMPORT     ("GDI32",    int,      GetObjectA,                    (HGDIOBJ obj, int bufsize, void* buffer));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GetObjectType,                 (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteDC,                      (HDC dc));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteObject,                  (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetTextColor,                  (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetBkColor,                    (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    int,      SetBkMode,                     (HDC dc, int bkMode));
_TX_DLLIMPORT     ("GDI32",    HFONT,    CreateFontA,                   (int height, int width, int escapement, int orientation,
                                                                         int weight, DWORD italic, DWORD underline, DWORD strikeout,
                                                                         DWORD charSet, DWORD outputPrec, DWORD clipPrec,
                                                                         DWORD quality, DWORD pitchAndFamily, const char face[]));
_TX_DLLIMPORT     ("GDI32",    int,      EnumFontFamiliesExA,           (HDC dc, LPLOGFONT logFont, FONTENUMPROC enumProc,
                                                                         LPARAM lParam, DWORD reserved));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetPixel,                      (HDC dc, int x, int y, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, GetPixel,                      (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    HPEN,     CreatePen,                     (int penStyle, int width, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    HBRUSH,   CreateSolidBrush,              (COLORREF color));
_TX_DLLIMPORT     ("GDI32",    bool,     MoveToEx,                      (HDC dc, int x, int y, POINT* point));
_TX_DLLIMPORT     ("GDI32",    bool,     LineTo,                        (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    bool,     Polygon,                       (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Polyline,                      (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     PolyBezier,                    (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Rectangle,                     (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     RoundRect,                     (HDC dc, int x0, int y0, int x1, int y1, int sizeX, int sizeY));
_TX_DLLIMPORT     ("GDI32",    bool,     Ellipse,                       (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     Arc,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Pie,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Chord,                         (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     TextOutA,                      (HDC dc, int x, int y, const char string[], int length));
_TX_DLLIMPORT     ("GDI32",    UINT,     SetTextAlign,                  (HDC dc, unsigned mode));
_TX_DLLIMPORT     ("GDI32",    bool,     GetTextExtentPoint32A,         (HDC dc, const char string[], int length, SIZE* size));
_TX_DLLIMPORT     ("GDI32",    bool,     ExtFloodFill,                  (HDC dc, int x, int y, COLORREF color, unsigned type));
_TX_DLLIMPORT     ("GDI32",    bool,     BitBlt,                        (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src,  int xSrc,  int ySrc,  DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     StretchBlt,                    (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src, int xSrc, int ySrc, int wSrc, int hSrc, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     PlgBlt,                        (HDC dest, const POINT* parallelogram,
                                                                         HDC src, int xSrc, int ySrc, int width, int height,
                                                                         HBITMAP mask, int xMask, int yMask));
_TX_DLLIMPORT     ("GDI32",    int,      SetDIBitsToDevice,             (HDC dc, int xDest, int yDest, DWORD width, DWORD height,
                                                                         int xSrc, int ySrc, unsigned startLine, unsigned numLines,
                                                                         const void* data, const BITMAPINFO* info, unsigned colorUse));
_TX_DLLIMPORT     ("GDI32",    int,      GetDIBits,                     (HDC hdc, HBITMAP hbmp, unsigned uStartScan, unsigned cScanLines,
                                                                         void* lpvBits, BITMAPINFO* lpbi, unsigned usage));
_TX_DLLIMPORT     ("GDI32",    bool,     PatBlt,                        (HDC dc, int x0, int y0, int width, int height, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    int,      SetROP2,                       (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    int,      SetStretchBltMode,             (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GdiSetBatchLimit,              (DWORD limit));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateDIBSection,              (HDC dc, const BITMAPINFO* bmInfo, unsigned colorUsage, void **vBits,
                                                                         HANDLE section, DWORD offset));

_TX_DLLIMPORT     ("User32",   int,      DrawTextA,                     (HDC dc, const char text[], int length, RECT* rect, unsigned format));
_TX_DLLIMPORT     ("User32",   HANDLE,   LoadImageA,                    (HINSTANCE inst, const char name[], unsigned type,
                                                                        int sizex, int sizey, unsigned mode));
_TX_DLLIMPORT_OPT ("User32",   bool,     IsHungAppWindow,               (HWND wnd));
_TX_DLLIMPORT_OPT ("User32",   HWND,     GhostWindowFromHungWindow,     (HWND wnd));

_TX_DLLIMPORT     ("WinMM",    bool,     PlaySound,                     (const char sound[], HMODULE mod, DWORD mode));

_TX_DLLIMPORT_OPT ("MSImg32",  bool,     TransparentBlt,                (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         unsigned transparentColor));
_TX_DLLIMPORT_OPT ("MSImg32",  bool,     AlphaBlend,                    (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         BLENDFUNCTION blending));

_TX_DLLIMPORT     ("Kernel32", void,     ExitProcess,                   (unsigned retcode));
_TX_DLLIMPORT     ("Kernel32", bool,     TerminateProcess,              (HANDLE process, unsigned retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalExit,                     (int retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalAppExitA,                 (unsigned action, const char message[]));
_TX_DLLIMPORT     ("Kernel32", HWND,     GetConsoleWindow,              (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetConsoleFont,                (HANDLE con, DWORD fontIndex));
_TX_DLLIMPORT_OPT ("Kernel32", DWORD,    GetNumberOfConsoleFonts,       (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFont,         (HANDLE con, bool maxWnd, CONSOLE_FONT_INFO*   curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", void,     RtlCaptureContext,             (CONTEXT* contextRecord));
_TX_DLLIMPORT_OPT ("Kernel32", USHORT,   RtlCaptureStackBackTrace,      (DWORD framesToSkip, DWORD framesToCapture, void** backTrace, DWORD* hash));
_TX_DLLIMPORT_OPT ("Kernel32", void*,    AddVectoredExceptionHandler,   (unsigned long firstHandler, PVECTORED_EXCEPTION_HANDLER handler));
_TX_DLLIMPORT_OPT ("Kernel32", unsigned, RemoveVectoredExceptionHandler,(void* handler));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetModuleHandleEx,             (DWORD flags, const char moduleName[], HMODULE* module));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     IsWow64Process,                (HANDLE process, int* isWow64Process));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     Wow64GetThreadContext,         (HANDLE thread, WOW64_CONTEXT* context));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetThreadStackGuarantee,       (unsigned long* stackSize));

_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoInitialize,                  (void*));
_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoCreateInstance,              (REFCLSID clsId, IUnknown*, DWORD, REFIID iId, PVOID* value));
_TX_DLLIMPORT     ("OLE32",    void,     CoUninitialize,                (void));

_TX_DLLIMPORT     ("Shell32",  HINSTANCE,ShellExecuteA,                 (HWND wnd, const char operation[], const char file[],
                                                                         const char parameters[], const char directory[], int showCmd));

_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIA,                      (const char    string[], const char    search[]));
_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIW,                      (const wchar_t string[], const wchar_t search[]));

_TX_DLLIMPORT_OPT ("NTDLL",    char*,    wine_get_version,              (void));
_TX_DLLIMPORT     ("NTDLL",    NTSTATUS, NtQueryInformationProcess,     (HANDLE process, int infoClass,
                                                                         void* processInfo, unsigned long szProcessInfo, unsigned long* szReturnInfo));

_TX_DLLIMPORT_CRT ("MSVCRT",   void,     exit,                          (int retcode));
_TX_DLLIMPORT_CRT ("MSVCRT",   void,     _cexit,                        (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _fpreset,                      (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _controlfp,                    (unsigned control, unsigned mask));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthread,                  (void (__cdecl* start_address) (void*), unsigned stack_size, void* arglist));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthreadex,                (void* security, unsigned stack_size, unsigned (__stdcall* start_address) (void*),
                                                                         void *arglist, unsigned init_flag, unsigned* thread_addr));
_TX_DLLIMPORT_CRT ("MSVCRT",   char*,    __unDName,                     (char* outStr, const char* mangledName, int outStrLen,
                                                                         void* (*mallocFunc) (size_t size), void (*freeFunc) (void *pointer),
                                                                         unsigned short flags));
_TX_DLLIMPORT_CRT ("MSVCRT",   unexpected_handler, set_unexpected,      (unexpected_handler handler));

_TX_DLLIMPORT_OPT ("OpenGL32", HDC,         wglGetCurrentDC,            (void));
_TX_DLLIMPORT_OPT ("OpenGL32", unsigned,    glGetError,                 (void));
_TX_DLLIMPORT_OPT ("Glu32",    const char*, gluErrorString,             (unsigned error));

_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     MiniDumpWriteDump,             (HANDLE process, DWORD processId, HANDLE file, MINIDUMP_TYPE dumpType,
                                                                         MINIDUMP_EXCEPTION_INFORMATION*   exceptionParam,
                                                                         MINIDUMP_USER_STREAM_INFORMATION* userStreamParam,
                                                                         MINIDUMP_CALLBACK_INFORMATION*    callbackParam));

_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("DbgHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
namespace MinGW {
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("MgwHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
} // namespace MinGW

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal function prototypes, macros and constants
//  @name    Ïðîòîòèïû âíóòðåííèõ ôóíêöèé, ìàêðîñû è êîíñòàíòû
//=================================================================================================================
//! @{

const int        _TX_IDM_ABOUT                            =   40000,       // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
                 _TX_IDM_CONSOLE                          =   40001,
                 _TX_WM_CREATEWND                         =   0x7FF0,      // Ñîîáùåíèÿ äëÿ ñîçäàíèÿ/óíè÷òîæåíèÿ
                 _TX_WM_DESTROYWND                        =   0x7FF1;      // îêîí â ïîòîêå Canvas

//-----------------------------------------------------------------------------------------------------------------

int              _txInitialize();
void             _txCleanup();

HWND             _txCanvas_CreateWindow      (const SIZE* size);
inline bool      _txCanvas_OK() tx_nodiscard;

bool             _txCanvas_OnCREATE          (HWND wnd);
bool             _txCanvas_OnDESTROY         (HWND wnd);
bool             _txCanvas_OnCLOSE           (HWND);
bool             _txCanvas_OnPAINT           (HWND wnd);
bool             _txCanvas_OnKEYDOWN         (HWND wnd, WPARAM vk, LPARAM info);
bool             _txCanvas_OnCHAR            (HWND wnd, WPARAM ch, LPARAM info);
bool             _txCanvas_OnTIMER           (HWND wnd, WPARAM id);
bool             _txCanvas_OnMOUSEMOVE       (HWND wnd, WPARAM buttons, LPARAM coords);
bool             _txCanvas_OnMOUSELEAVE      (HWND wnd);
bool             _txCanvas_OnCREATEWND       (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnDESTROYWND      (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnCmdCONSOLE      (HWND wnd, WPARAM cmd);
bool             _txCanvas_OnCmdABOUT        (HWND wnd, WPARAM cmd);

unsigned WINAPI  _txCanvas_ThreadProc        (void* data);
LRESULT CALLBACK _txCanvas_WndProc           (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);

int              _txCanvas_SetRefreshLock    (int count);

HDC              _txBuffer_Create            (HWND wnd = NULL, const POINT* size = NULL, HBITMAP bitmap = NULL,
                                              RGBQUAD** pixels = NULL) tx_nodiscard;
bool             _txBuffer_Delete            (HDC* dc);
bool             _txBuffer_Select            (HGDIOBJ obj, HDC dc = txDC());

HWND             _txConsole_Attach();
bool             _txConsole_OK() tx_nodiscard;
bool             _txConsole_Detach           (bool activate);
bool             _txConsole_Draw             (HDC dc);
bool             _txConsole_SetUnicodeFont();

const char*       txRegisterClass            (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra);
HWND              txCreateExtraWindow        (CREATESTRUCT createData);
HICON            _txCreateTXIcon             (int size) tx_nodiscard;
int              _txSetFinishedText          (HWND wnd);
void             _txPauseBeforeTermination   (HWND canvas);
int              _txIsParentWaitable         (DWORD* parentPID = NULL) tx_nodiscard;
int              _txGetInput();

LRESULT CALLBACK _txPlayVideo_WndProc        (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
const char*      _txPlayVideo_FindVLC() tx_nodiscard;

bool             _txCreateShortcut           (const char shortcutName[],
                                              const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
                                              const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
                                              const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
                                              COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));

void*            _tx_DLGTEMPLATE_Create      (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                                              WORD controls, short x, short y, short cx, short cy,
                                              const char caption[], const char font[], WORD fontsize,
                                              const char menu[]) tx_nodiscard;

void*            _tx_DLGTEMPLATE_Add         (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                                              short x, short y, short cx, short cy,
                                              WORD id, const char wclass[], const char caption[]);

const char*      _txError                    (const char file[] = NULL, int line = 0, const char func[] = NULL, unsigned color = 0,
                                              const char msg[] = NULL, ...) tx_printfy (5);
const char*      _txProcessError             (const char file[], int line, const char func[], unsigned color,
                                              const char msg[], va_list args);
void             _txOnTerminate();
void             _txOnUnexpected();
void             _txOnPureCall();
void             _txOnNewHandlerAnsi();
int              _txOnNewHandler             (size_t size);
void             _txOnSignal                 (int signal = 0, int fpe = 0);
BOOL WINAPI      _txOnConsoleCtrlEvent       (DWORD type);
void             _txOnSecurityError          (int code, void*);
void             _txOnSecurityErrorAnsi      (const char* msg, void* ptr, int code);
int              _txOnMatherr                (_exception* except);
void             _txOnInvalidParam           (const wchar_t* expr, const wchar_t* func, const wchar_t* file,
                                              unsigned line, uintptr_t);
int              _txOnAllocHook              (int type, void* data, size_t size, int use, long request,
                                              const unsigned char* file, int line);
int              _txOnRTCFailure             (int type, const char* file, int line, const char* module, const char* format, ...) tx_printfy (5);
int              _txOnErrorReport            (int type, const char* text, int* ret);
int               tx_glGetError              (int setError = INT_MIN);

void             _txOnCExit();
void             _txOnExit                   (int      retcode);
void             _txOnFatalExit              (int      retcode);
void             _txOnExitProcess            (unsigned retcode);
void             _txOnFatalAppExitA          (unsigned action, const char message[]);
bool             _txOnTerminateProcess       (HANDLE process, unsigned retcode);
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
                 _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter);
void             _txWatchdogTerminator       (void* timeout);  // Only Arnold-type series are supported, not T1000

long WINAPI      _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc);
long WINAPI      _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc);
long             _txOnExceptionSEH           (EXCEPTION_POINTERS* exc, const char func[]);
intptr_t         _txDumpExceptionSEH         (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[]);
intptr_t         _txDumpExceptionObj         (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type);
intptr_t         _txDumpExceptionCPP         (char what[], intptr_t size, unsigned code = 0,
                                              unsigned params = 0, const ULONG_PTR info[] = NULL);

void             _txStackBackTrace           (const char file[] = "?", int line = 0, const char func[] = "?",
                                              bool readSource = true);
const char*      _txCaptureStackBackTrace    (int framesToSkip = 0, bool readSource = true,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
int              _txStackWalk                (int framesToSkip, size_t szCapture, void* capture[], unsigned long* backTraceHash,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
const char*      _txCaptureStackBackTraceTX  (int framesToSkip = 0, bool readSource = false);

const char*      _txSymPrintFromAddr         (void* addr = NULL, const char format[] = NULL, ...) tx_printfy (2);
bool             _txSymGetFromAddr           (void* addr, Win32::SYMBOL_INFO** symbol = NULL,
                                              Win32::IMAGEHLP_LINE64** line = NULL, const char** module = NULL,
                                              const char** source = NULL, int context = 2);
intptr_t         _txReadSource               (char buf[], intptr_t size, const char file[],
                                              int linStart = 0, int linEnd = INT_MIN, int linMark = INT_MIN);
bool             _txCreateMiniDump           (EXCEPTION_POINTERS* exc);

uintptr_t        _txSetProcAddress           (const char funcName[], uintptr_t newFunc, const char dllName[] = NULL,
                                              int useHotPatching = false, HMODULE module = NULL, bool debug = false);
bool             _txInDll() tx_nodiscard;
PROCESSENTRY32*  _txFindProcess              (unsigned pid = GetCurrentProcessId()) tx_nodiscard;
bool             _txKillProcess              (DWORD pid);
bool             _txIsBadReadPtr             (const void* address);
bool             _txCheckSourceCP            (int needCP = _TX_CODEPAGE, bool verbose = true);
bool             _txGetCommandLine           (wchar_t cmdLine[], size_t szCmdLine, unsigned pid = _getpid());
IMAGE_NT_HEADERS*_txGetNtHeaders             (HMODULE module = GetModuleHandle (NULL)) tx_nodiscard;
const char*      _txAppInfo() tx_nodiscard;

intptr_t         _tx_snprintf_s              (char stream[], intptr_t size, const char format[], ...) tx_printfy (3);
intptr_t         _tx_vsnprintf_s             (char stream[], intptr_t size, const char format[], va_list arg);
void              txReopenStdio();

#if defined (_CLANG_VER) && !defined (_MSC_VER)
void             _txLibCppDebugFunction      (std::__libcpp_debug_info const& info);
#endif

#if defined (__CYGWIN__)

int              _getch();
int              _putch (int ch);
int              _kbhit() tx_nodiscard;

#endif

//-----------------------------------------------------------------------------------------------------------------
// There are macros for __FILE__ and __LINE__ to work properly.

#if !defined (NDEBUG)

    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) && \
                                                     (assert (cond), true) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå."), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("Ïàðàìåòð \"%s\" íåâåðåí. Âîçìîæíî, ýòîò õîëñò íå ñîçäàí, " \
                                                                "èëè óæå óíè÷òîæåí, èëè íå çàãðóçèëàñü êàðòèíêà.", #dc), 1) )
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( (!(dc) &&                                           \
                                                     _TX_TXWINDOW_FAILED()) || _TX_HDC_FAILED (dc) )

#else
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define _TX_DEFAULT_HDC_FAILED(dc)         ( !(dc) &&                                            \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
#endif

//-----------------------------------------------------------------------------------------------------------------
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but MSVC rejects it. So sad. :'(

#if !defined (NDEBUG)
    #define  _TX_ON_DEBUG( code )              { code; }
#else
    #define  _TX_ON_DEBUG( code )              ;
#endif

//-----------------------------------------------------------------------------------------------------------------
// Invokes an error without location information. "$$" restores TX-related call location context

#define _TX_UNEXPECTED( ... )                  $$ _txError (NULL, 0, NULL, 0, ##__VA_ARGS__)

//-----------------------------------------------------------------------------------------------------------------
// Safe call of a function via its pointer

#define _TX_CALL(  func, param )               ( (func)? ((func) param) :       0 )
#define _TX_CALLv( func, param )               ( (func)? ((func) param) : (void)0 )

//-----------------------------------------------------------------------------------------------------------------
// This is a macro because cond is an expression and is not always a function. Lack of lambdas in pre-C++0x.

#define      _txWaitFor( cond, time )          { for (DWORD _t = GetTickCount() + (time); \
                                                      !(cond) && GetTickCount() < _t;     \
                                                      Sleep (_txWindowUpdateInterval)) ;  \
                                                 if  (!(cond))                            \
                                                      _txTrace (__FILE__, __LINE__, NULL, "WARNING: Timeout: " #cond "."); }
//-----------------------------------------------------------------------------------------------------------------
// Detouring in case of SEH mechanism

#define _txSetJmp()                            ( setjmp (_txDumpExceptionObjJmp) == 0 )

#define _txClearJmp()                          { *(unsigned long long*) _txDumpExceptionObjJmp = 0; }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal global data
//! @name    Âíóòðåííèå ãëîáàëüíûå äàííûå
//
//           Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
//           Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåð, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
//           Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
//           Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé, èëè êëàññ.
//=================================================================================================================
//! @{

int                          _txInitialized              = _TX_NOINIT || _txInitialize();

volatile const unsigned      _txCanaryFirst              = 0x776F656D; // A very system value

volatile unsigned            _txMainThreadId             = 0;          // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
volatile HANDLE              _txMainThread               = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà

volatile unsigned            _txCanvas_ThreadId          = 0;          // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
volatile HANDLE              _txCanvas_Thread            = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
volatile HWND                _txCanvas_Window            = NULL;       // Äåñêðèïòîð îêíà õîëñòà TXLib

HDC                          _txCanvas_BackBuf[2]        = {NULL,      // [0] Main TXLib in-memory DC, where user's pictures lies
                                                            NULL};     // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()

RGBQUAD*                     _txCanvas_Pixels            = NULL;       // Memory buffer of _txCanvas_BackBuf[0]

HBITMAP                      _txStockBitmap              = NULL;       // Equivalent of GetStockObject (BITMAP),
                                                                       // see https://devblogs.microsoft.com/oldnewthing/20100416-00/?p=14313

CRITICAL_SECTION             _txCanvas_LockBackBuf       = {0,-1};     // Prevent simultaneous access to back buffer, see txLock()

UINT_PTR                     _txCanvas_RefreshTimer      = 1;          // Timer ID to redraw TXLib window
volatile int                 _txCanvas_RefreshLock       = 0;          // Blocks auto on-timer canvas update, see txBegin/txEnd

::std::vector<HDC>*          _txCanvas_UserDCs           = NULL;       // List of DCs allocated, for auto-free

volatile bool                _txConsole_IsBlinking       = true;       // To blink or not to blink, that is the question.

bool                         _txConsole                  = false;      // Only first TXLib module in app can own the console
bool                         _txMain                     = false;      // First TXLib wnd opened (closing it terminates program)
bool                         _txIsDll                    = false;      // TXLib module is in DLL
volatile bool                _txRunning                  = false;      // main() is still running
volatile bool                _txExit                     = false;      // exit() is active

volatile POINT               _txMousePos                 = {-1,-1};    // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
volatile unsigned            _txMouseButtons             = 0;

volatile WNDPROC             _txAltWndProc               = NULL;       // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().

_tx_thread _txLoc            _txLoc::Cur                 = {};         // Execution point tracking and trace state, see "$" macro

volatile int                 _txErrors                   = 0;          // TX_ERROR calls sequental number
int                          _txOGLError                 = 0;          // Last OpenGL error when using tx_glGetError()
volatile long                _txSENumber                 = 0;          // SEH exceptions sequental number
volatile long                _txSEFatalNumber            = 0;          // SEH fatal exceptions sequental number
char                         _txDumpSE [_TX_BUFSIZE]     = "";         // SEH dump data area
char                         _txTraceSE[_TX_HUGEBUFSIZE] = "";         // Stack trace data area

LPTOP_LEVEL_EXCEPTION_FILTER _txPrevUEFilter             = NULL;       // Previous UnhandledExceptionFilter

jmp_buf                      _txDumpExceptionObjJmp      = {};         // Hook for _txDumpExceptionObj

const volatile uintptr_t     _txForceImport[]            = { (uintptr_t) ::TerminateProcess,              (uintptr_t) ::ExitProcess,
                                                             (uintptr_t) ::FatalExit,                     (uintptr_t) ::FatalAppExitA,
                                                             (uintptr_t) ::exit,                          (uintptr_t) Win32::_controlfp,
                                                             (uintptr_t) Win32::Polyline,                 (uintptr_t) Win32::PolyBezier,
                                                             (uintptr_t) Win32::RoundRect,                (uintptr_t) Win32::RemoveVectoredExceptionHandler,
                                                             (uintptr_t) Win32::PlgBlt,                   (uintptr_t) Win32::RtlCaptureStackBackTrace,
                                                             (uintptr_t) Win32::SymInitialize,            (uintptr_t) Win32::MinGW::SymInitialize,
                                                             (uintptr_t) Win32::SymSetOptions,            (uintptr_t) Win32::MinGW::SymSetOptions,
                                                             (uintptr_t) Win32::SymGetLineFromAddr64,     (uintptr_t) Win32::MinGW::SymGetLineFromAddr64,
                                                             (uintptr_t) Win32::SymFromAddr,              (uintptr_t) Win32::MinGW::SymFromAddr,
                                                             (uintptr_t) Win32::SymCleanup,               (uintptr_t) Win32::MinGW::SymCleanup,
                                                             (uintptr_t) Win32::SymGetModuleBase64,       (uintptr_t) Win32::MinGW::SymGetModuleBase64,
                                                             (uintptr_t) Win32::SymFunctionTableAccess64, (uintptr_t) Win32::MinGW::SymFunctionTableAccess64,
                                                             (uintptr_t) Win32::StackWalk64,              (uintptr_t) Win32::MinGW::StackWalk64,
                                                             (uintptr_t) Win32::StrStrIA,                 (uintptr_t) Win32::Wow64GetThreadContext };

volatile const unsigned      _txCanaryLast               = 0x5E2E2E5E; // Another very system value

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib engine init/check/cleanup
//! @name    Èíèöèàëèçàöèÿ/ïðîâåðêà/çàâåðøåíèå TXLib
//=================================================================================================================
//! @{

//-----------------------------------------------------------------------------------------------------------------
//{          Early initialization
//-----------------------------------------------------------------------------------------------------------------

int _txInitialize()
    {
    if (_txInitialized) return 1;
    _txInitialized = 1;

    #if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)  // See http://msdn.microsoft.com/en-us/library/w2fhc9a3%28v=vs.90%29.aspx
    _CrtSetBreakAlloc (_TX_ALLOC_BREAK);                 // and http://support.microsoft.com/ru-ru/kb/151585
    #endif

    #if defined (_TX_ALLOW_TRACE)
    _txLocLvlSet (1);
    #endif

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
                                     "compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

    _txMainThreadId = GetCurrentThreadId();
    _txMainThread   = OpenThread (THREAD_ALL_ACCESS, false, _txMainThreadId);

$3  _txIsDll = _txInDll();

$   if (!_txIsDll)
        {
$       _txConsole = ! FindAtom ("_txConsole");
$       (void)          AddAtom ("_txConsole");
        }

$   if (_txConsole)
        {
$       _txCheckSourceCP (_TX_CODEPAGE, true);

$       unsigned long stackSize = _TX_STACKSIZE;
$       _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$       _txOnSignal();

$       if (!*_txLogName)
            {$ _tx_snprintf_s (_txLogName, sizeof (_txLogName) - 1, "%s.log", txGetModuleFileName()); }

$       if (!_txIsDll)
            {
$           _TX_CALL  (Win32::AddVectoredExceptionHandler, (1, (PVECTORED_EXCEPTION_HANDLER)  _txVectoredExceptionHandler));
$           _txPrevUEFilter = SetUnhandledExceptionFilter  (   (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter);
            }

$       ::std::set_terminate             (_txOnTerminate);
$       ::std::set_new_handler           (_txOnNewHandlerAnsi);
$       _TX_CALL (Win32::set_unexpected, (_txOnUnexpected));

        #if defined (_CLANG_VER) && !defined (_MSC_VER)
$       ::std::__libcpp_debug_function = _txLibCppDebugFunction;
        #endif

$       SetConsoleCtrlHandler (_txOnConsoleCtrlEvent, true);

$       SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);

        #if defined (_MSC_VER)

$       _set_printf_count_output (1);

$       _set_new_handler (_txOnNewHandler);
$       _set_new_mode (1);

        #if !defined (_CLANG_VER)

$       _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$       _CrtSetAllocHook (_txOnAllocHook);

$       unsigned mode = _CRTDBG_MODE_FILE;
$       if (_CrtSetReportHook2 (_CRT_RPTHOOK_INSTALL, (_CRT_REPORT_HOOK) _txOnErrorReport) > 0) mode = 0;

$       _CrtSetReportMode (_CRT_WARN,   _CRTDBG_MODE_DEBUG | mode);
$       _CrtSetReportMode (_CRT_ERROR,  _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportFile (_CRT_WARN,   _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ERROR,  _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);

        #endif

$       _set_abort_behavior (_WRITE_ABORT_MSG, _WRITE_ABORT_MSG);
$       _set_abort_behavior (0,                _CALL_REPORTFAULT);

$       _RTC_SetErrorFunc              (_txOnRTCFailure);
$       _set_purecall_handler          (_txOnPureCall);
$       _set_invalid_parameter_handler (_txOnInvalidParam);

        #endif

        #if defined (__STDC_LIB_EXT1__)
$       ::std::set_constraint_handler_s (_txOnSecurityErrorAnsi);
        #endif

        #if !defined (__CYGWIN__) && defined (_GCC_VER) && (_GCC_VER >= 530) && !defined (i386)
$       __setusermatherr (_txOnMatherr);
        #endif

        #if !defined (__CYGWIN__)
$       _set_error_mode (_OUT_TO_MSGBOX | _OUT_TO_STDERR);
        #endif

$       HWND console = _txConsole_Attach();
$       SetWindowTextA (console, txGetModuleFileName (false));
        }

$   InitializeCriticalSection (&_txCanvas_LockBackBuf);

$   _txSetProcAddress ("ExitProcess",                 (uintptr_t) _txOnExitProcess,                 "KERNEL32.DLL");
$   _txSetProcAddress ("TerminateProcess",            (uintptr_t) _txOnTerminateProcess,            "KERNEL32.DLL");
$   _txSetProcAddress ("FatalExit",                   (uintptr_t) _txOnFatalExit,                   "KERNEL32.DLL");
$   _txSetProcAddress ("FatalAppExitA",               (uintptr_t) _txOnFatalAppExitA,               "KERNEL32.DLL");
$   _txSetProcAddress ("UnhandledExceptionFilter",    (uintptr_t) _txUnhandledExceptionFilter,      "KERNEL32.DLL", true);
$   _txSetProcAddress ("SetUnhandledExceptionFilter", (uintptr_t) _txOnSetUnhandledExceptionFilter, "KERNEL32.DLL");
$   _txSetProcAddress ("exit",                        (uintptr_t) _txOnExit);
$   _txSetProcAddress ("_cexit",                      (uintptr_t) _txOnCExit);

$   atexit (_txCleanup);

$   if (_txConsole)
        {
$       txSetConsoleAttr (FOREGROUND_LIGHTGRAY);

$       tx_fpreset();

$       srand ((unsigned) time (NULL));

$       SetLastError (0);
$       errno = 0;

        #if !defined (__CYGWIN__)
$       _doserrno = 0;
        #endif
        }

$   HDC dc = Win32::CreateCompatibleDC (NULL); dc asserted;
$   _txStockBitmap = (HBITMAP) Win32::SelectObject (dc, Win32::CreateCompatibleBitmap (dc, 1, 1)); _txStockBitmap asserted;
$   Win32::DeleteObject (Win32::SelectObject (dc, _txStockBitmap)) asserted;
$   Win32::DeleteDC (dc) asserted;

$   return 1;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCheckSourceCP (int needCP /*= _TX_CODEPAGE*/, bool verbose /*= true*/)
    {
$3  const char* sCodePage = NULL;
$   int codePage = 0;

$   switch (((unsigned const char*) "À") [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }

$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please

$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }

$   return (codePage == needCP);
    }

//-----------------------------------------------------------------------------------------------------------------

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;

    static char dllPaths [2][MAX_PATH] = {"", ""};

    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";

        // dllPaths[0] is relative to the TX Setup directory stored in the Registry

        char* path = dllPaths[0];

        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);

        // dllPaths[1] is relative to TXib.h file used in compilation

        path = dllPaths[1];

        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }

        if (char* dir = strrchr (path, '\\')) *dir = 0;

        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }

    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);

    if (arch)
        {
        assert (arch >= dllFileName);

        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));

        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }

    HMODULE   dll = GetModuleHandle (dllFileName);

    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);

    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);

        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);

        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }

    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);

    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;

    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);

    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè
#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
    // ðåñóðñîâ è ñèñòåìû ñáîðêè. Ïîýòîìó äëÿ íåçàâèñèìîñòè îò íèõ âñå áóäåò ñòðîèòüñÿ íà ýòàïå âûïîëíåíèÿ,
    // äèíàìè÷åñêè. Âû åùå ãëÿíüòå, êàê ýòî ðåàëèçîâàíî â txDialog::dialogBox() è ôóíêöèÿõ _tx_DLGTEMPLATE_()... Î_î    //-------------------------------------------------------------------------------------------------------------

    #define ID_TEXT_  101
    #define ID_INPUT_ 102

    //-------------------------------------------------------------------------------------------------------------
    // Çàäàíèå ìàêåòà (âèäà) äèàëîãà â âèäå ìàññèâà ñòðóêòóð.
    // Ñ ïîìîùüþ îñîáîãî ïîðÿäêà ïîëåé â ñòðóêòóðå txDialog::Layout è êîíñòàíò èç êëàññà txDialog ýòîò ìàññèâ
    // ñòàíîâèòñÿ ïîõîæ íà îïèñàíèå ðåñóðñà äèàëîãà â .rc-ôàéëå.
    // Ñì. îïèñàíèå ñèíòàêñèñà rc-ôàéëà â äîêóìåíòàöèè ïî Win32 (MSDN, http://msdn.com).
    //-------------------------------------------------------------------------------------------------------------

    txDialog::Layout layout[] =

    //----------------------+----------+-----------+-----------------+---------------------------------------------
    //     Òèï ýëåìåíòà     | Èìÿ      | Èäåíòè-   |   Êîîðäèíàòû    | Ôëàãè ýëåìåíòîâ
    //     äèàëîãà          | ýëåìåíòà | ôèêàòîð   |-----------------| (ñì. îïèñàíèå ýëåìåíòîâ
    //                      |          | ýëåìåíòà  | X | Y |Øèð.|Âûñ.| îêîí äèàëîãà â MSDN)
    //----------------------+----------+-----------+---+---+----+----+---------------------------------------------
    //                      |          |           |   |   |    |    |
        {{ txDialog::DIALOG,  caption,   0,           0,  0, 240,  85                                                    },
         { txDialog::STATIC,  text,      ID_TEXT_,   10, 10, 150,  40, SS_LEFT                                           },
         { txDialog::EDIT,    input,     ID_INPUT_,  10, 60, 220,  15, ES_LEFT | WS_BORDER | ES_AUTOHSCROLL | WS_TABSTOP },
         { txDialog::BUTTON,  "&OK",     IDOK,      180, 10,  50,  15, BS_DEFPUSHBUTTON                     | WS_TABSTOP },
         { txDialog::BUTTON,  "&Cancel", IDCANCEL,  180, 30,  50,  15, BS_PUSHBUTTON                        | WS_TABSTOP },
         { txDialog::END                                                                                                 }};

    //-------------------------------------------------------------------------------------------------------------
    // Êëàññ äèàëîãà äëÿ InputBox. Âíóòðåííèé, ò.ê. çà÷åì åìó áûòü âíåøíèì.
    // Íóæåí â îñíîâíîì äëÿ çàäàíèÿ ñòðîêè ââîäà (str) è îêîííîé ôóíêöèè äèàëîãîâîãî îêíà, òðåáóåìîé Win32 (îíà
    // ïîñòðîåíà ìàêðîñàìè TX_BEGIN_MESSAGE_MAP è äðóãèìè). Ìîæíî íå äåëàòü âíóòðåííåãî êëàññà, íî òîãäà îêîííóþ
    // ôóíêöèþ ïðèäåòñÿ ïèñàòü â ãëîáàëüíîé îáëàñòè âèäèìîñòè, è str îáúÿâëÿòü ãëîáàëüíî òîæå (èëè ïåðåäàâàòü åå
    // àäðåñ ÷åðåç DialogBoxParam è çàïèñûâàòü åãî â êëàññ âî âðåìÿ îáðàáîòêè WM_INITDIALOG).
    //-------------------------------------------------------------------------------------------------------------
    struct inputDlg : txDialog
        {
        char str [1024];

        //---------------------------------------------------------------------------------------------------------

        inputDlg() :
            str()
            {}

        //---------------------------------------------------------------------------------------------------------

        TX_BEGIN_MESSAGE_MAP()    // Êàðòà ñîîáùåíèé (íà ñàìîì äåëå ýòî íà÷àëî îêîííîé ôóíêöèè).

            TX_COMMAND_MAP        // Çäåñü îáðàáàòûâàþòñÿ WM_COMMAND (íà ñàìîì äåëå ýòî îïåðàòîð switch).

                //-------------------------------------------------------------------------------------------------
                // Ïðè íàæàòèè êíîïêè OK êîïèðóåì ñòðîêó èç ïîëÿ ââîäà â íàøó ïåðåìåííóþ str, ò.ê. ïîñëå çàêðûòèÿ
                // äèàëîãà ñòðîêà ââîäà óìðåò è òåêñò óæå èç íåå ïîëó÷èòü.
                // Ýòîò ìàêðîñ íà ñàìîì äåëå ïðåâðàùàåòñÿ â case èç îïåðàòîðà switch.
                // _wnd -- ýòî ïàðàìåòð îêîííîé ôóíêöèè, ñì. îïðåäåëåíèå ìàêðîñà TX_BEGIN_MESSAGE_MAP().
                //-------------------------------------------------------------------------------------------------

                TX_HANDLE (IDOK) GetDlgItemText (_wnd, ID_INPUT_, str, sizeof (str) - 1);

        TX_END_MESSAGE_MAP

        //---------------------------------------------------------------------------------------------------------
        // Êîíåö âíóòðåííåãî êëàññà äèàëîãà
        //---------------------------------------------------------------------------------------------------------
        };

    //-------------------------------------------------------------------------------------------------------------
    // Óáèðàåì äåôàéíû, ÷òîáû ïîòîì íå ìåøàëè.
    // Îò ýòîãî îíè ïîëó÷àþòñÿ "ëîêàëüíîãî äåéñòâèÿ", êàê áóäòî ó íèõ áûëà áû îáëàñòü âèäèìîñòè -- ôóíêöèÿ. Íà ñàìîì
    // äåëå ýòî ñäåëàíî âðó÷íóþ ÷åðåç #undef. ×òîáû ïîä÷åðêíóòü èõ ëîêàëüíóþ ïðèðîäó, ó íèõ èìåíà çàêàí÷èâàþòñÿ íà _.
    // Òàêèå äåôàéíû ïîòîì íå ïåðåêîñÿ÷àò âåñü êîä ïîñëå òîãî êàê, ôàêòè÷åñêè, ñòàëè óæå íå íóæíû.
    //-------------------------------------------------------------------------------------------------------------

    #undef ID_TEXT_
    #undef ID_INPUT_

    //-------------------------------------------------------------------------------------------------------------
    // Ýòî ñòàòè÷åñêèé îáúåêò, ïîòîìó ÷òî ñòðîêà â íåì äîëæíà æèòü ïîñëå çàâåðøåíèÿ ôóíêöèè.
    //-------------------------------------------------------------------------------------------------------------

    static inputDlg dlg;

    //-------------------------------------------------------------------------------------------------------------
    // Ïåðåäàåì layout è çàïóñêàåì îêíî äèàëîãà
    //-------------------------------------------------------------------------------------------------------------

    dlg.dialogBox (layout);

    //-------------------------------------------------------------------------------------------------------------
    // Âîçâðàùàåì àäðåñ ñòðîêè èç ñòàòè÷åñêîãî îáúåêòà. Òàê ìîæíî äåëàòü, ïîòîìó ÷òî ñòàòè÷åñêèé îáúåêò íå óìðåò
    // ïðè âûõîäå èç ôóíêöèè è ñòðîêà â íåì, ñîîòâåòñòâåííî, òîæå. Àäðåñ íåñòàòè÷åñêèõ ïåðåìåííûõ ïåðåäàâàòü
    // ñèíòàêñè÷åñêè ìîæíî, íî âåäåò ê ñåðüåçíûì îøèáêàì.
    //-------------------------------------------------------------------------------------------------------------

    return dlg.str;
    }

//! @}
//}
//=================================================================================================================

//}
//=================================================================================================================

//=================================================================================================================
//{          TXLIB IMPLEMENTATION
//           Ðåàëèçàöèÿ ôóíêöèé áèáëèîòåêè
//=================================================================================================================
//! @cond INTERNAL

//=================================================================================================================
//{          DLL functions import, missing types definitions
//! @name    Èìïîðò âíåøíèõ áèáëèîòåê, îïðåäåëåíèå íåäîñòàþùèõ òèïîâ
//=================================================================================================================
//! @{

namespace Win32 {

//-----------------------------------------------------------------------------------------------------------------
//{ Some of structs, consts and interfaces aren't defined in MinGW some early headers.
//  Copied from Windows SDK 7.0a.
//-----------------------------------------------------------------------------------------------------------------

#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                             0x01
#endif

#ifndef SMTO_ERRORONEXIT
#define SMTO_ERRORONEXIT                         0x0020
#endif

#ifndef NT_CONSOLE_PROPS_SIG
#define NT_CONSOLE_PROPS_SIG                     0xA0000002
#endif

#ifndef NIIF_INFO
#define NIIF_INFO                                0x00000001
#define NIIF_WARNING                             0x00000002
#define NIIF_ERROR                               0x00000003
#endif

#ifndef NIF_INFO
#define NIF_STATE                                0x00000008
#define NIF_INFO                                 0x00000010
#endif

#ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
#define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS   0x00000004
#endif

#ifndef SYMOPT_CASE_INSENSITIVE
#define SYMOPT_CASE_INSENSITIVE                  0x00000001
#define SYMOPT_UNDNAME                           0x00000002
#define SYMOPT_DEFERRED_LOADS                    0x00000004
#define SYMOPT_NO_CPP                            0x00000008
#define SYMOPT_LOAD_LINES                        0x00000010
#define SYMOPT_OMAP_FIND_NEAREST                 0x00000020
#define SYMOPT_LOAD_ANYTHING                     0x00000040
#define SYMOPT_IGNORE_CVREC                      0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS              0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS              0x00000200
#define SYMOPT_EXACT_SYMBOLS                     0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS            0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH                 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES             0x00002000
#define SYMOPT_PUBLICS_ONLY                      0x00004000
#define SYMOPT_NO_PUBLICS                        0x00008000
#define SYMOPT_AUTO_PUBLICS                      0x00010000
#define SYMOPT_NO_IMAGE_SEARCH                   0x00020000
#define SYMOPT_SECURE                            0x00040000
#define SYMOPT_NO_PROMPTS                        0x00080000
#define SYMOPT_ALLOW_ZERO_ADDRESS                0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT         0x02000000
#define SYMOPT_FAVOR_COMPRESSED                  0x00800000
#define SYMOPT_FLAT_DIRECTORY                    0x00400000
#define SYMOPT_IGNORE_IMAGEDIR                   0x00200000
#define SYMOPT_OVERWRITE                         0x00100000
#define SYMOPT_DEBUG                             0x80000000
#endif

// SEH exception codes. For GCC, see http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 64-66.

#ifndef STATUS_POSSIBLE_DEADLOCK
#define STATUS_POSSIBLE_DEADLOCK                 0xC0000194
#endif

#ifndef STATUS_FLOAT_MULTIPLE_FAULTS
#define STATUS_FLOAT_MULTIPLE_FAULTS             0xC00002B4
#endif

#ifndef STATUS_STACK_BUFFER_OVERRUN
#define STATUS_STACK_BUFFER_OVERRUN              0xC0000409
#endif

#ifndef STATUS_ASSERTION_FAILURE
#define STATUS_ASSERTION_FAILURE                 0xC0000420
#endif

#ifndef STATUS_WX86_BREAKPOINT
#define STATUS_WX86_BREAKPOINT                   0x4000001F
#endif

#ifndef DBG_PRINTEXCEPTION_C
#define DBG_PRINTEXCEPTION_C                     0x40010006  // OutputDebugStringA() call
#endif

#ifndef DBG_PRINTEXCEPTION_WIDE_C
#define DBG_PRINTEXCEPTION_WIDE_C                0x4001000A  // OutputDebugStringW() call
#endif

#ifndef DBG_THREAD_NAME
#define DBG_THREAD_NAME                          0x406D1388
#endif

#define EXCEPTION_CPP_MSC                        0xE06D7363  // '?msc'
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1       0x19930520  // '?msc' version magic, see ehdata.h
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2       0x19930521  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3       0x19930522  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1  0x01994000  // '?msc' version magic

#define EXCEPTION_CPP_GCC                        0x20474343  // ' GCC'
#define EXCEPTION_CPP_GCC_UNWIND                 0x21474343  // '!GCC'
#define EXCEPTION_CPP_GCC_FORCED                 0x22474343  // '"GCC'

#define EXCEPTION_CLR_FAILURE                    0xE0434f4D  // 'àCOM'

#define EXCEPTION_CPP_BORLAND_BUILDER            0x0EEDFAE6  // Should never occur here
#define EXCEPTION_CPP_BORLAND_DELPHI             0x0EEDFADE  // Should never occur here

#pragma pack (push, 1)

struct CONSOLE_CURSOR_INFO
    {
    DWORD dwSize;
    BOOL bVisible;
    };

struct CONSOLE_FONT_INFO
    {
    DWORD nFont;
    COORD dwFontSize;
    };

struct CONSOLE_FONT_INFOEX
    {
    ULONG cbSize;
    DWORD nFont;
    COORD dwFontSize;
    UINT  FontFamily;
    UINT  FontWeight;
    WCHAR FaceName[LF_FACESIZE];
    };

struct DATABLOCK_HEADER
    {
    DWORD cbSize;
    DWORD dwSignature;
    };

struct NT_CONSOLE_PROPS
    {
    DATABLOCK_HEADER dbh;

    WORD  wFillAttribute;
    WORD  wPopupFillAttribute;
    COORD dwScreenBufferSize;
    COORD dwWindowSize;
    COORD dwWindowOrigin;
    DWORD nFont;
    DWORD nInputBufferSize;
    COORD dwFontSize;
    UINT  uFontFamily;
    UINT  uFontWeight;
    WCHAR FaceName[LF_FACESIZE];
    UINT  uCursorSize;
    BOOL  bFullScreen;
    BOOL  bQuickEdit;
    BOOL  bInsertMode;
    BOOL  bAutoPosition;
    UINT  uHistoryBufferSize;
    UINT  uNumberOfHistoryBuffers;
    BOOL  bHistoryNoDup;

    COLORREF ColorTable[16];
    };

#pragma pack (pop)

#undef  INTERFACE
#define INTERFACE IShellLinkDataList

DECLARE_INTERFACE_ (IShellLinkDataList, IUnknown)
    {
    // *** IUnknown methods ***
    STDMETHOD (QueryInterface)  (THIS_ REFIID iid, void** value)    _tx_override PURE;
    STDMETHOD_(ULONG, AddRef)   (THIS)                              _tx_override PURE;
    STDMETHOD_(ULONG, Release)  (THIS)                              _tx_override PURE;

    // *** IShellLinkDataList methods ***
    STDMETHOD (AddDataBlock)    (THIS_ void* dataBlock)             PURE;
    STDMETHOD (CopyDataBlock)   (THIS_ DWORD sig, void** dataBlock) PURE;
    STDMETHOD (RemoveDataBlock) (THIS_ DWORD sig)                   PURE;
    STDMETHOD (GetFlags)        (THIS_ DWORD* flags)                PURE;
    STDMETHOD (SetFlags)        (THIS_ DWORD  flags)                PURE;

    protected:
    virtual ~IShellLinkDataList();
    };

const GUID IID_IShellLink         = {0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID IID_IShellLinkDataList = {0x45e2b4ae, 0xb1c3, 0x11d0, {0xb9,0x2f,0x00,0xa0,0xc9,0x03,0x12,0xe1}};
const GUID IID_IPersistFile       = {0x0000010b, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};

const GUID CLSID_SpVoice          = {0x96749377, 0x3391, 0x11d2, {0x9e,0xe3,0x00,0xc0,0x4f,0x79,0x73,0x96}};
const GUID IID_ISpVoice           = {0x6c44df74, 0x72b9, 0x4992, {0xa1,0xec,0xef,0x99,0x6e,0x04,0x22,0xd4}};

#undef  INTERFACE

typedef DWORD     NTSTATUS;
typedef ULONG_PTR KAFFINITY;
typedef LONG      KPRIORITY;

struct UNICODE_STRING
    {
    USHORT Length;
    USHORT MaximumLength;
    WCHAR* Buffer;
    };

struct RTL_USER_PROCESS_PARAMETERS
    {
    BYTE  Reserved1[16];
    void* Reserved2[10];
    UNICODE_STRING ImagePathName;
    UNICODE_STRING CommandLine;
    };

struct PEB
    {
    BYTE  Reserved1[2];
    BYTE  BeingDebugged;
    BYTE  Reserved2[1];
    void* Reserved3[2];
    void* Ldr;
    RTL_USER_PROCESS_PARAMETERS* ProcessParameters;
    void* Reserved4[3];
    void* AtlThunkSListPtr;
    void* Reserved5;
    ULONG Reserved6;
    void* Reserved7;
    ULONG Reserved8;
    ULONG AtlThunkSListPtr32;
    void* Reserved9[45];
    BYTE  Reserved10[96];
    void* PostProcessInitRoutine;
    BYTE  Reserved11[128];
    void* Reserved12[1];
    ULONG SessionId;
    };

struct PROCESS_BASIC_INFORMATION
    {
    NTSTATUS  ExitStatus;
    PEB*      PebBaseAddress;
    KAFFINITY AffinityMask;
    KPRIORITY BasePriority;
    ULONG_PTR UniqueProcessId;
    ULONG_PTR InheritedFromUniqueProcessId;
    };

enum ADDRESS_MODE
    {
    AddrMode1616,
    AddrMode1632,
    AddrModeReal,
    AddrModeFlat
    };

struct ADDRESS64
    {
    DWORD64      Offset;
    WORD         Segment;
    ADDRESS_MODE Mode;
    };

struct KDHELP64
    {
    DWORD64 Thread;
    DWORD   ThCallbackStack;
    DWORD   ThCallbackBStore;
    DWORD   NextCallback;
    DWORD   FramePointer;
    DWORD64 KiCallUserMode;
    DWORD64 KeUserCallbackDispatcher;
    DWORD64 SystemRangeStart;
    DWORD64 KiUserExceptionDispatcher;
    DWORD64 StackBase;
    DWORD64 StackLimit;
    DWORD64 Reserved[5];
    };

struct STACKFRAME64
    {
    ADDRESS64 AddrPC;
    ADDRESS64 AddrReturn;
    ADDRESS64 AddrFrame;
    ADDRESS64 AddrStack;
    ADDRESS64 AddrBStore;
    PVOID     FuncTableEntry;
    DWORD64   Params[4];
    BOOL      Far;
    BOOL      Virtual;
    DWORD64   Reserved[3];
    KDHELP64  KdHelp;
    };

struct WOW64_FLOATING_SAVE_AREA
    {
    DWORD ControlWord;
    DWORD StatusWord;
    DWORD TagWord;
    DWORD ErrorOffset;
    DWORD ErrorSelector;
    DWORD DataOffset;
    DWORD DataSelector;
    BYTE  RegisterArea[80];
    DWORD Cr0NpxState;
    };

#pragma pack (push, 4)

struct WOW64_CONTEXT
    {
    DWORD ContextFlags;

    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;

    WOW64_FLOATING_SAVE_AREA FloatSave;

    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;

    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;

    DWORD Ebp;
    DWORD Eip;
    DWORD SegCs;
    DWORD EFlags;
    DWORD Esp;
    DWORD SegSs;

    BYTE  ExtendedRegisters[512];
    };

#pragma pack (pop)

struct SYMBOL_INFO
    {
    ULONG   SizeOfStruct;
    ULONG   TypeIndex;
    ULONG64 Reserved[2];
    ULONG   info;
    ULONG   Size;
    ULONG64 ModBase;
    ULONG   Flags;
    ULONG64 Value;
    ULONG64 Address;
    ULONG   Register;
    ULONG   Scope;
    ULONG   Tag;
    ULONG   NameLen;
    ULONG   MaxNameLen;
    CHAR    Name[1];
    };

struct IMAGEHLP_LINE64
    {
    DWORD   SizeOfStruct;
    PVOID   Key;
    DWORD   LineNumber;
    PCHAR   FileName;
    DWORD64 Address;
    };

typedef bool    (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)   (HANDLE process, DWORD64 baseAddress, void* buffer, DWORD size, DWORD* bytesRead);
typedef void*   (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64) (HANDLE process, DWORD64 baseAddress);
typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)       (HANDLE process, DWORD64 address);
typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)     (HANDLE process, HANDLE thread, ADDRESS64* address);

typedef void (*unexpected_handler)();

#pragma pack (push, 4)

struct MINIDUMP_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    };

struct MINIDUMP_THREAD_EX_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    ULONG64  BackingStoreBase;
    ULONG64  BackingStoreEnd;
    };

struct MINIDUMP_MODULE_CALLBACK
    {
    wchar_t* FullPath;
    ULONG64  BaseOfImage;
    ULONG    SizeOfImage;
    ULONG    CheckSum;
    ULONG    TimeDateStamp;
    VS_FIXEDFILEINFO VersionInfo;
    void*    CvRecord;
    ULONG    SizeOfCvRecord;
    PVOID    MiscRecord;
    ULONG    SizeOfMiscRecord;
    };

struct MINIDUMP_INCLUDE_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    };

struct MINIDUMP_INCLUDE_MODULE_CALLBACK
    {
    ULONG64  BaseOfImage;
    };

struct MINIDUMP_MEMORY_INFO
    {
    ULONG64  BaseAddress;
    ULONG64  AllocationBase;
    ULONG32  AllocationProtect;
    ULONG32  __alignment1;
    ULONG64  RegionSize;
    ULONG32  State;
    ULONG32  Protect;
    ULONG32  Type;
    ULONG32  __alignment2;
    };

struct MINIDUMP_USER_STREAM
    {
    ULONG32  Type;
    ULONG    BufferSize;
    PVOID    Buffer;
    };

struct MINIDUMP_USER_STREAM_INFORMATION
    {
    ULONG                 UserStreamCount;
    MINIDUMP_USER_STREAM* UserStreamArray;
    };

struct MINIDUMP_CALLBACK_INPUT
    {
    ULONG    ProcessId;
    HANDLE   ProcessHandle;
    ULONG    CallbackType;

    union
        {
        MINIDUMP_THREAD_CALLBACK         Thread;
        MINIDUMP_THREAD_EX_CALLBACK      ThreadEx;
        MINIDUMP_MODULE_CALLBACK         Module;
        MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
        MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
        };
    };

struct MINIDUMP_CALLBACK_OUTPUT
    {
    union
        {
        ULONG ModuleWriteFlags;
        ULONG ThreadWriteFlags;
        ULONG SecondaryFlags;

        struct
            {
            ULONG64  MemoryBase;
            ULONG    MemorySize;
            };

        struct
            {
            unsigned CheckCancel;
            unsigned Cancel;
            };

        HANDLE Handle;
        };

    struct
        {
        MINIDUMP_MEMORY_INFO VmRegion;
        unsigned             Continue;
        };

    HRESULT Status;
    };

struct MINIDUMP_EXCEPTION_INFORMATION
    {
    DWORD               ThreadId;
    EXCEPTION_POINTERS* ExceptionPointers;
    unsigned            ClientPointers;
    };

typedef int (WINAPI* MINIDUMP_CALLBACK_ROUTINE) (void* param, MINIDUMP_CALLBACK_INPUT* input, MINIDUMP_CALLBACK_OUTPUT* output);

struct MINIDUMP_CALLBACK_INFORMATION
    {
    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
    void*                     CallbackParam;
    };

enum MINIDUMP_TYPE
    {
    MiniDumpNormal                         = 0x00000000,
    MiniDumpWithDataSegs                   = 0x00000001,
    MiniDumpWithFullMemory                 = 0x00000002,
    MiniDumpWithHandleData                 = 0x00000004,
    MiniDumpFilterMemory                   = 0x00000008,
    MiniDumpScanMemory                     = 0x00000010,
    MiniDumpWithUnloadedModules            = 0x00000020,
    MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
    MiniDumpFilterModulePaths              = 0x00000080,
    MiniDumpWithProcessThreadData          = 0x00000100,
    MiniDumpWithPrivateReadWriteMemory     = 0x00000200,
    MiniDumpWithoutOptionalData            = 0x00000400,
    MiniDumpWithFullMemoryInfo             = 0x00000800,
    MiniDumpWithThreadInfo                 = 0x00001000,
    MiniDumpWithCodeSegs                   = 0x00002000,
    MiniDumpWithoutAuxiliaryState          = 0x00004000,
    MiniDumpWithFullAuxiliaryState         = 0x00008000,
    MiniDumpWithPrivateWriteCopyMemory     = 0x00010000,
    MiniDumpIgnoreInaccessibleMemory       = 0x00020000,
    MiniDumpWithTokenInformation           = 0x00040000
    };

#pragma pack (pop)

#define FOREGROUND_BLACK         ( 0                                                         )
#define FOREGROUND_CYAN          ( FOREGROUND_BLUE       | FOREGROUND_GREEN                  )
#define FOREGROUND_MAGENTA       ( FOREGROUND_BLUE       | FOREGROUND_RED                    )
#define FOREGROUND_DARKYELLOW    ( FOREGROUND_GREEN      | FOREGROUND_RED                    )
#define FOREGROUND_LIGHTGRAY     ( FOREGROUND_BLUE       | FOREGROUND_GREEN | FOREGROUND_RED )
#define FOREGROUND_DARKGRAY      (                         FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTBLUE     ( FOREGROUND_BLUE       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTGREEN    ( FOREGROUND_GREEN      | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTCYAN     ( FOREGROUND_CYAN       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTRED      ( FOREGROUND_RED        | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTMAGENTA  ( FOREGROUND_MAGENTA    | FOREGROUND_INTENSITY              )
#define FOREGROUND_YELLOW        ( FOREGROUND_DARKYELLOW | FOREGROUND_INTENSITY              )
#define FOREGROUND_WHITE         ( FOREGROUND_LIGHTGRAY  | FOREGROUND_INTENSITY              )

#define BACKGROUND_BLACK         ( 0                                                         )
#define BACKGROUND_CYAN          ( BACKGROUND_BLUE       | BACKGROUND_GREEN                  )
#define BACKGROUND_MAGENTA       ( BACKGROUND_BLUE       | BACKGROUND_RED                    )
#define BACKGROUND_DARKYELLOW    ( BACKGROUND_GREEN      | BACKGROUND_RED                    )
#define BACKGROUND_GRAY          ( BACKGROUND_BLUE       | BACKGROUND_GREEN | BACKGROUND_RED )
#define BACKGROUND_DARKGRAY      (                         BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTBLUE     ( BACKGROUND_BLUE       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTGREEN    ( BACKGROUND_GREEN      | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTCYAN     ( BACKGROUND_CYAN       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTRED      ( BACKGROUND_RED        | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTMAGENTA  ( BACKGROUND_MAGENTA    | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTYELLOW   ( BACKGROUND_DARKYELLOW | BACKGROUND_INTENSITY              )
#define BACKGROUND_WHITE         ( BACKGROUND_DARKGRAY   | BACKGROUND_INTENSITY              )

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ There are copies of MSVC compiler built-in predefined definitions, which are wrong in 64-bit mode.
//  So we have to override them. See: http://stackoverflow.com/questions/39113168
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)
                                                    //  MS ABI C++ Exception Layout
namespace Win32 {                                   //  ---------------------------
                                                    //
#pragma pack (push, 4)                              //   EXCEPTION_RECORD:
                                                    //  +==================================================+
struct ThrowInfo                                    //  |...                                               |
    {                                               //  |NumberParameters:        3, 4 or more             |
    __int32 attributes;                             //  |ExceptionInformation[0]: MS signature 0x19930520  |
    __int32 pmfnUnwind;                             //  |ExceptionInformation[1]: object* thrown           |
    __int32 pForwardCompat;                         //  |ExceptionInformation[2]: ThrowInfo* --------------+---+
    __int32 pCatchableTypeArray;                    //  |ExceptionInformation[3]: ImageBase (if params > 3)|   |
    };                                              //  +==================================================+   |
                                                    //                                                         |
struct CatchableTypeArray                           //        ThrowInfo:                                       |
    {                                               //        +======================================+ <-------+
    __int32 nCatchableTypes;                        //        |   ...                                |
    __int32 arrayOfCatchableTypes[];                //  +-----+-- pCatchableTypeArray (ptr/RVA)      |
    };                                              //  |     +======================================+
                                                    //  |
struct CatchableType                                //  |     CatchableTypeArray:
    {                                               //  +---> +======================================+
    __int32 properties;                             //        |   ...                                |
    __int32 pType;                                  //  +-----+-- arrayOfCatchableTypes[0] (ptr/RVA) |
    __int32 thisDisplacement[3]; // struct _PMD     //  |     +======================================+
    __int32 sizeOrOffset;                           //  |
    __int32 copyFunction;                           //  |     CatchableType:
    };                                              //  +---> +====================+
                                                    //        | ...                |        std::type_info:
#pragma pack (pop)                                  //        | pType (ptr/RVA) ---+------> +==================+
                                                    //        | ...                |        |type_info data    |
} // namespace Win32                                //        +====================+        |...               |
                                                    //                                      +==================+
#endif

// Similar to __CxxDetectRethrow(), see C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\crtsrc\vcruntime\frame.cpp:

#define _TX_MSC__CXX_DETECT_RETHROW( exc )                                     \
    (                                                                          \
    (exc)                                          &&                          \
    (exc) -> ExceptionCode    == EXCEPTION_CPP_MSC &&                          \
    (exc) -> NumberParameters >= 3                 &&                          \
                                                                               \
    ((exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3) && \
                                                                               \
    (exc) -> ExceptionInformation[2] == 0                                      \
    )

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ The corresponding structures for GCC
//
//  From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/unwind-cxx.h
//  See:  http://mentorembedded.github.io/cxx-abi/abi-eh.html#cxx-abi
//-----------------------------------------------------------------------------------------------------------------

#if defined (_GCC_VER)
                                                    // GCC ABI C++ Exception layout. A/B are ExceptionInformation[0].
namespace ABI {                                     // --------------------------------------------------------------
                                                    //
struct __cxa_exception                              // Case A: "_Unwind_Exception* A" is undependent exception:
    {                                               // --------------------------------------------------------
    union {                                         //
        struct                                      //           __cxa_exception:           std::type_info:
            {                                       //       -*--+====================+     +==================+
            ::std::type_info* exceptionType;        //        ^  |exceptionType* -----+---->|type_info data    |
            void (*exceptionDestructor)(void*);     //        |  |...                 |     |...               |
            };                                      //       -1  |                    |     +==================+
        struct                                      //        |  |                    |
            {                                       // A >----|--+--------------------+
            __cxa_exception*  primaryException;     //     |  |  |unwindHeader        |
            void (*padding)();                      //    +1  |  |                    |
            };                                      //     |  |  |                    |
        };                                          //     V  |  |                    |
                                                    //    -*---  +====================+
    std::unexpected_handler   unexpectedHandler;    //           |object              |
    std::terminate_handler    terminateHandler;     //           +--------------------+
                                                    //
    __cxa_exception*          nextException;        // Case B: "_Unwind_Exception* B" is dependent exception
    int                       handlerCount;         // (unwindHeader.exception_class & 1 != 0):
    int                       handlerSwitchValue;   // -----------------------------------------------------
    const unsigned char*      actionRecord;         //
    const unsigned char*      languageSpecificData; //           __cxa_exception:               __cxa_exception:
    void*                     catchTemp;            //       -*--+====================+     -*--+=================+
    void*                     adjustedPtr;          //        ^  |primaryException* --+--    ^  |exceptionType*   |
                                                    //        |  |...                 |  \   |  |...              |
    _Unwind_Exception         unwindHeader;         //       -1  |                    |  |   |  |                 |
    };                                              //        |  |                    |  |   |  |                 |
                                                    // B >----|--+--------------------+  |  -1  +-----------------+
struct __cxa_eh_globals                             //     |  |  |unwindHeader        |  |   |  |unwindHeader     |
    {                                               //    +1  |  |                    |  |   |  |                 |
    __cxa_exception* caughtExceptions;              //     |  |  |                    |  |   |  |                 |
    unsigned int     uncaughtExceptions;            //     V  |  |                    |  \   |  |                 |
    };                                              //    -*---  +====================+   -->*--+=================+
                                                    //           |...                 |         |object           |
} // namespace ABI                                  //           .                    .         |                 |
                                                    //                                          +-----------------+

extern "C" ABI::__cxa_eh_globals* __cxa_get_globals();

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ Hand-made IAT.
//  Some IDEs don't link with these libs by default in console projects, so do sunrise by hand. :(
//-----------------------------------------------------------------------------------------------------------------

// Hand-made DLLIMPORT helpers

#define _TX_DLLIMPORT(     lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, true)

#define _TX_DLLIMPORT_OPT( lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, false)

#define _TX_DLLIMPORT_CRT( lib, retval, name, params ) \
     retval (      * name) params = (retval (      *) params) _txDllImport (lib ".dll", #name, false)

typedef void (*_tx_FARPROC)();

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required = true);

//-----------------------------------------------------------------------------------------------------------------

namespace Win32 {

_TX_DLLIMPORT     ("GDI32",    HDC,      CreateCompatibleDC,            (HDC dc));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateCompatibleBitmap,        (HDC dc, int width, int height));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetStockObject,                (int object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  SelectObject,                  (HDC dc, HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetCurrentObject,              (HDC dc, unsigned objectType));
_TX_DLLIMPORT     ("GDI32",    int,      GetObjectA,                    (HGDIOBJ obj, int bufsize, void* buffer));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GetObjectType,                 (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteDC,                      (HDC dc));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteObject,                  (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetTextColor,                  (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetBkColor,                    (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    int,      SetBkMode,                     (HDC dc, int bkMode));
_TX_DLLIMPORT     ("GDI32",    HFONT,    CreateFontA,                   (int height, int width, int escapement, int orientation,
                                                                         int weight, DWORD italic, DWORD underline, DWORD strikeout,
                                                                         DWORD charSet, DWORD outputPrec, DWORD clipPrec,
                                                                         DWORD quality, DWORD pitchAndFamily, const char face[]));
_TX_DLLIMPORT     ("GDI32",    int,      EnumFontFamiliesExA,           (HDC dc, LPLOGFONT logFont, FONTENUMPROC enumProc,
                                                                         LPARAM lParam, DWORD reserved));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetPixel,                      (HDC dc, int x, int y, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, GetPixel,                      (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    HPEN,     CreatePen,                     (int penStyle, int width, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    HBRUSH,   CreateSolidBrush,              (COLORREF color));
_TX_DLLIMPORT     ("GDI32",    bool,     MoveToEx,                      (HDC dc, int x, int y, POINT* point));
_TX_DLLIMPORT     ("GDI32",    bool,     LineTo,                        (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    bool,     Polygon,                       (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Polyline,                      (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     PolyBezier,                    (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Rectangle,                     (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     RoundRect,                     (HDC dc, int x0, int y0, int x1, int y1, int sizeX, int sizeY));
_TX_DLLIMPORT     ("GDI32",    bool,     Ellipse,                       (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     Arc,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Pie,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Chord,                         (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     TextOutA,                      (HDC dc, int x, int y, const char string[], int length));
_TX_DLLIMPORT     ("GDI32",    UINT,     SetTextAlign,                  (HDC dc, unsigned mode));
_TX_DLLIMPORT     ("GDI32",    bool,     GetTextExtentPoint32A,         (HDC dc, const char string[], int length, SIZE* size));
_TX_DLLIMPORT     ("GDI32",    bool,     ExtFloodFill,                  (HDC dc, int x, int y, COLORREF color, unsigned type));
_TX_DLLIMPORT     ("GDI32",    bool,     BitBlt,                        (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src,  int xSrc,  int ySrc,  DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     StretchBlt,                    (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src, int xSrc, int ySrc, int wSrc, int hSrc, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     PlgBlt,                        (HDC dest, const POINT* parallelogram,
                                                                         HDC src, int xSrc, int ySrc, int width, int height,
                                                                         HBITMAP mask, int xMask, int yMask));
_TX_DLLIMPORT     ("GDI32",    int,      SetDIBitsToDevice,             (HDC dc, int xDest, int yDest, DWORD width, DWORD height,
                                                                         int xSrc, int ySrc, unsigned startLine, unsigned numLines,
                                                                         const void* data, const BITMAPINFO* info, unsigned colorUse));
_TX_DLLIMPORT     ("GDI32",    int,      GetDIBits,                     (HDC hdc, HBITMAP hbmp, unsigned uStartScan, unsigned cScanLines,
                                                                         void* lpvBits, BITMAPINFO* lpbi, unsigned usage));
_TX_DLLIMPORT     ("GDI32",    bool,     PatBlt,                        (HDC dc, int x0, int y0, int width, int height, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    int,      SetROP2,                       (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    int,      SetStretchBltMode,             (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GdiSetBatchLimit,              (DWORD limit));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateDIBSection,              (HDC dc, const BITMAPINFO* bmInfo, unsigned colorUsage, void **vBits,
                                                                         HANDLE section, DWORD offset));

_TX_DLLIMPORT     ("User32",   int,      DrawTextA,                     (HDC dc, const char text[], int length, RECT* rect, unsigned format));
_TX_DLLIMPORT     ("User32",   HANDLE,   LoadImageA,                    (HINSTANCE inst, const char name[], unsigned type,
                                                                        int sizex, int sizey, unsigned mode));
_TX_DLLIMPORT_OPT ("User32",   bool,     IsHungAppWindow,               (HWND wnd));
_TX_DLLIMPORT_OPT ("User32",   HWND,     GhostWindowFromHungWindow,     (HWND wnd));

_TX_DLLIMPORT     ("WinMM",    bool,     PlaySound,                     (const char sound[], HMODULE mod, DWORD mode));

_TX_DLLIMPORT_OPT ("MSImg32",  bool,     TransparentBlt,                (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         unsigned transparentColor));
_TX_DLLIMPORT_OPT ("MSImg32",  bool,     AlphaBlend,                    (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         BLENDFUNCTION blending));

_TX_DLLIMPORT     ("Kernel32", void,     ExitProcess,                   (unsigned retcode));
_TX_DLLIMPORT     ("Kernel32", bool,     TerminateProcess,              (HANDLE process, unsigned retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalExit,                     (int retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalAppExitA,                 (unsigned action, const char message[]));
_TX_DLLIMPORT     ("Kernel32", HWND,     GetConsoleWindow,              (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetConsoleFont,                (HANDLE con, DWORD fontIndex));
_TX_DLLIMPORT_OPT ("Kernel32", DWORD,    GetNumberOfConsoleFonts,       (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFont,         (HANDLE con, bool maxWnd, CONSOLE_FONT_INFO*   curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", void,     RtlCaptureContext,             (CONTEXT* contextRecord));
_TX_DLLIMPORT_OPT ("Kernel32", USHORT,   RtlCaptureStackBackTrace,      (DWORD framesToSkip, DWORD framesToCapture, void** backTrace, DWORD* hash));
_TX_DLLIMPORT_OPT ("Kernel32", void*,    AddVectoredExceptionHandler,   (unsigned long firstHandler, PVECTORED_EXCEPTION_HANDLER handler));
_TX_DLLIMPORT_OPT ("Kernel32", unsigned, RemoveVectoredExceptionHandler,(void* handler));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetModuleHandleEx,             (DWORD flags, const char moduleName[], HMODULE* module));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     IsWow64Process,                (HANDLE process, int* isWow64Process));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     Wow64GetThreadContext,         (HANDLE thread, WOW64_CONTEXT* context));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetThreadStackGuarantee,       (unsigned long* stackSize));

_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoInitialize,                  (void*));
_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoCreateInstance,              (REFCLSID clsId, IUnknown*, DWORD, REFIID iId, PVOID* value));
_TX_DLLIMPORT     ("OLE32",    void,     CoUninitialize,                (void));

_TX_DLLIMPORT     ("Shell32",  HINSTANCE,ShellExecuteA,                 (HWND wnd, const char operation[], const char file[],
                                                                         const char parameters[], const char directory[], int showCmd));

_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIA,                      (const char    string[], const char    search[]));
_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIW,                      (const wchar_t string[], const wchar_t search[]));

_TX_DLLIMPORT_OPT ("NTDLL",    char*,    wine_get_version,              (void));
_TX_DLLIMPORT     ("NTDLL",    NTSTATUS, NtQueryInformationProcess,     (HANDLE process, int infoClass,
                                                                         void* processInfo, unsigned long szProcessInfo, unsigned long* szReturnInfo));

_TX_DLLIMPORT_CRT ("MSVCRT",   void,     exit,                          (int retcode));
_TX_DLLIMPORT_CRT ("MSVCRT",   void,     _cexit,                        (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _fpreset,                      (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _controlfp,                    (unsigned control, unsigned mask));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthread,                  (void (__cdecl* start_address) (void*), unsigned stack_size, void* arglist));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthreadex,                (void* security, unsigned stack_size, unsigned (__stdcall* start_address) (void*),
                                                                         void *arglist, unsigned init_flag, unsigned* thread_addr));
_TX_DLLIMPORT_CRT ("MSVCRT",   char*,    __unDName,                     (char* outStr, const char* mangledName, int outStrLen,
                                                                         void* (*mallocFunc) (size_t size), void (*freeFunc) (void *pointer),
                                                                         unsigned short flags));
_TX_DLLIMPORT_CRT ("MSVCRT",   unexpected_handler, set_unexpected,      (unexpected_handler handler));

_TX_DLLIMPORT_OPT ("OpenGL32", HDC,         wglGetCurrentDC,            (void));
_TX_DLLIMPORT_OPT ("OpenGL32", unsigned,    glGetError,                 (void));
_TX_DLLIMPORT_OPT ("Glu32",    const char*, gluErrorString,             (unsigned error));

_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     MiniDumpWriteDump,             (HANDLE process, DWORD processId, HANDLE file, MINIDUMP_TYPE dumpType,
                                                                         MINIDUMP_EXCEPTION_INFORMATION*   exceptionParam,
                                                                         MINIDUMP_USER_STREAM_INFORMATION* userStreamParam,
                                                                         MINIDUMP_CALLBACK_INFORMATION*    callbackParam));

_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("DbgHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
namespace MinGW {
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("MgwHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
} // namespace MinGW

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal function prototypes, macros and constants
//  @name    Ïðîòîòèïû âíóòðåííèõ ôóíêöèé, ìàêðîñû è êîíñòàíòû
//=================================================================================================================
//! @{

const int        _TX_IDM_ABOUT                            =   40000,       // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
                 _TX_IDM_CONSOLE                          =   40001,
                 _TX_WM_CREATEWND                         =   0x7FF0,      // Ñîîáùåíèÿ äëÿ ñîçäàíèÿ/óíè÷òîæåíèÿ
                 _TX_WM_DESTROYWND                        =   0x7FF1;      // îêîí â ïîòîêå Canvas

//-----------------------------------------------------------------------------------------------------------------

int              _txInitialize();
void             _txCleanup();

HWND             _txCanvas_CreateWindow      (const SIZE* size);
inline bool      _txCanvas_OK() tx_nodiscard;

bool             _txCanvas_OnCREATE          (HWND wnd);
bool             _txCanvas_OnDESTROY         (HWND wnd);
bool             _txCanvas_OnCLOSE           (HWND);
bool             _txCanvas_OnPAINT           (HWND wnd);
bool             _txCanvas_OnKEYDOWN         (HWND wnd, WPARAM vk, LPARAM info);
bool             _txCanvas_OnCHAR            (HWND wnd, WPARAM ch, LPARAM info);
bool             _txCanvas_OnTIMER           (HWND wnd, WPARAM id);
bool             _txCanvas_OnMOUSEMOVE       (HWND wnd, WPARAM buttons, LPARAM coords);
bool             _txCanvas_OnMOUSELEAVE      (HWND wnd);
bool             _txCanvas_OnCREATEWND       (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnDESTROYWND      (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnCmdCONSOLE      (HWND wnd, WPARAM cmd);
bool             _txCanvas_OnCmdABOUT        (HWND wnd, WPARAM cmd);

unsigned WINAPI  _txCanvas_ThreadProc        (void* data);
LRESULT CALLBACK _txCanvas_WndProc           (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);

int              _txCanvas_SetRefreshLock    (int count);

HDC              _txBuffer_Create            (HWND wnd = NULL, const POINT* size = NULL, HBITMAP bitmap = NULL,
                                              RGBQUAD** pixels = NULL) tx_nodiscard;
bool             _txBuffer_Delete            (HDC* dc);
bool             _txBuffer_Select            (HGDIOBJ obj, HDC dc = txDC());

HWND             _txConsole_Attach();
bool             _txConsole_OK() tx_nodiscard;
bool             _txConsole_Detach           (bool activate);
bool             _txConsole_Draw             (HDC dc);
bool             _txConsole_SetUnicodeFont();

const char*       txRegisterClass            (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra);
HWND              txCreateExtraWindow        (CREATESTRUCT createData);
HICON            _txCreateTXIcon             (int size) tx_nodiscard;
int              _txSetFinishedText          (HWND wnd);
void             _txPauseBeforeTermination   (HWND canvas);
int              _txIsParentWaitable         (DWORD* parentPID = NULL) tx_nodiscard;
int              _txGetInput();

LRESULT CALLBACK _txPlayVideo_WndProc        (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
const char*      _txPlayVideo_FindVLC() tx_nodiscard;

bool             _txCreateShortcut           (const char shortcutName[],
                                              const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
                                              const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
                                              const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
                                              COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));

void*            _tx_DLGTEMPLATE_Create      (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                                              WORD controls, short x, short y, short cx, short cy,
                                              const char caption[], const char font[], WORD fontsize,
                                              const char menu[]) tx_nodiscard;

void*            _tx_DLGTEMPLATE_Add         (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                                              short x, short y, short cx, short cy,
                                              WORD id, const char wclass[], const char caption[]);

const char*      _txError                    (const char file[] = NULL, int line = 0, const char func[] = NULL, unsigned color = 0,
                                              const char msg[] = NULL, ...) tx_printfy (5);
const char*      _txProcessError             (const char file[], int line, const char func[], unsigned color,
                                              const char msg[], va_list args);
void             _txOnTerminate();
void             _txOnUnexpected();
void             _txOnPureCall();
void             _txOnNewHandlerAnsi();
int              _txOnNewHandler             (size_t size);
void             _txOnSignal                 (int signal = 0, int fpe = 0);
BOOL WINAPI      _txOnConsoleCtrlEvent       (DWORD type);
void             _txOnSecurityError          (int code, void*);
void             _txOnSecurityErrorAnsi      (const char* msg, void* ptr, int code);
int              _txOnMatherr                (_exception* except);
void             _txOnInvalidParam           (const wchar_t* expr, const wchar_t* func, const wchar_t* file,
                                              unsigned line, uintptr_t);
int              _txOnAllocHook              (int type, void* data, size_t size, int use, long request,
                                              const unsigned char* file, int line);
int              _txOnRTCFailure             (int type, const char* file, int line, const char* module, const char* format, ...) tx_printfy (5);
int              _txOnErrorReport            (int type, const char* text, int* ret);
int               tx_glGetError              (int setError = INT_MIN);

void             _txOnCExit();
void             _txOnExit                   (int      retcode);
void             _txOnFatalExit              (int      retcode);
void             _txOnExitProcess            (unsigned retcode);
void             _txOnFatalAppExitA          (unsigned action, const char message[]);
bool             _txOnTerminateProcess       (HANDLE process, unsigned retcode);
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
                 _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter);
void             _txWatchdogTerminator       (void* timeout);  // Only Arnold-type series are supported, not T1000

long WINAPI      _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc);
long WINAPI      _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc);
long             _txOnExceptionSEH           (EXCEPTION_POINTERS* exc, const char func[]);
intptr_t         _txDumpExceptionSEH         (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[]);
intptr_t         _txDumpExceptionObj         (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type);
intptr_t         _txDumpExceptionCPP         (char what[], intptr_t size, unsigned code = 0,
                                              unsigned params = 0, const ULONG_PTR info[] = NULL);

void             _txStackBackTrace           (const char file[] = "?", int line = 0, const char func[] = "?",
                                              bool readSource = true);
const char*      _txCaptureStackBackTrace    (int framesToSkip = 0, bool readSource = true,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
int              _txStackWalk                (int framesToSkip, size_t szCapture, void* capture[], unsigned long* backTraceHash,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
const char*      _txCaptureStackBackTraceTX  (int framesToSkip = 0, bool readSource = false);

const char*      _txSymPrintFromAddr         (void* addr = NULL, const char format[] = NULL, ...) tx_printfy (2);
bool             _txSymGetFromAddr           (void* addr, Win32::SYMBOL_INFO** symbol = NULL,
                                              Win32::IMAGEHLP_LINE64** line = NULL, const char** module = NULL,
                                              const char** source = NULL, int context = 2);
intptr_t         _txReadSource               (char buf[], intptr_t size, const char file[],
                                              int linStart = 0, int linEnd = INT_MIN, int linMark = INT_MIN);
bool             _txCreateMiniDump           (EXCEPTION_POINTERS* exc);

uintptr_t        _txSetProcAddress           (const char funcName[], uintptr_t newFunc, const char dllName[] = NULL,
                                              int useHotPatching = false, HMODULE module = NULL, bool debug = false);
bool             _txInDll() tx_nodiscard;
PROCESSENTRY32*  _txFindProcess              (unsigned pid = GetCurrentProcessId()) tx_nodiscard;
bool             _txKillProcess              (DWORD pid);
bool             _txIsBadReadPtr             (const void* address);
bool             _txCheckSourceCP            (int needCP = _TX_CODEPAGE, bool verbose = true);
bool             _txGetCommandLine           (wchar_t cmdLine[], size_t szCmdLine, unsigned pid = _getpid());
IMAGE_NT_HEADERS*_txGetNtHeaders             (HMODULE module = GetModuleHandle (NULL)) tx_nodiscard;
const char*      _txAppInfo() tx_nodiscard;

intptr_t         _tx_snprintf_s              (char stream[], intptr_t size, const char format[], ...) tx_printfy (3);
intptr_t         _tx_vsnprintf_s             (char stream[], intptr_t size, const char format[], va_list arg);
void              txReopenStdio();

#if defined (_CLANG_VER) && !defined (_MSC_VER)
void             _txLibCppDebugFunction      (std::__libcpp_debug_info const& info);
#endif

#if defined (__CYGWIN__)

int              _getch();
int              _putch (int ch);
int              _kbhit() tx_nodiscard;

#endif

//-----------------------------------------------------------------------------------------------------------------
// There are macros for __FILE__ and __LINE__ to work properly.

#if !defined (NDEBUG)

    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) && \
                                                     (assert (cond), true) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå."), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("Ïàðàìåòð \"%s\" íåâåðåí. Âîçìîæíî, ýòîò õîëñò íå ñîçäàí, " \
                                                                "èëè óæå óíè÷òîæåí, èëè íå çàãðóçèëàñü êàðòèíêà.", #dc), 1) )
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( (!(dc) &&                                           \
                                                     _TX_TXWINDOW_FAILED()) || _TX_HDC_FAILED (dc) )

#else
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define _TX_DEFAULT_HDC_FAILED(dc)         ( !(dc) &&                                            \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
#endif

//-----------------------------------------------------------------------------------------------------------------
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but MSVC rejects it. So sad. :'(

#if !defined (NDEBUG)
    #define  _TX_ON_DEBUG( code )              { code; }
#else
    #define  _TX_ON_DEBUG( code )              ;
#endif

//-----------------------------------------------------------------------------------------------------------------
// Invokes an error without location information. "$$" restores TX-related call location context

#define _TX_UNEXPECTED( ... )                  $$ _txError (NULL, 0, NULL, 0, ##__VA_ARGS__)

//-----------------------------------------------------------------------------------------------------------------
// Safe call of a function via its pointer

#define _TX_CALL(  func, param )               ( (func)? ((func) param) :       0 )
#define _TX_CALLv( func, param )               ( (func)? ((func) param) : (void)0 )

//-----------------------------------------------------------------------------------------------------------------
// This is a macro because cond is an expression and is not always a function. Lack of lambdas in pre-C++0x.

#define      _txWaitFor( cond, time )          { for (DWORD _t = GetTickCount() + (time); \
                                                      !(cond) && GetTickCount() < _t;     \
                                                      Sleep (_txWindowUpdateInterval)) ;  \
                                                 if  (!(cond))                            \
                                                      _txTrace (__FILE__, __LINE__, NULL, "WARNING: Timeout: " #cond "."); }
//-----------------------------------------------------------------------------------------------------------------
// Detouring in case of SEH mechanism

#define _txSetJmp()                            ( setjmp (_txDumpExceptionObjJmp) == 0 )

#define _txClearJmp()                          { *(unsigned long long*) _txDumpExceptionObjJmp = 0; }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal global data
//! @name    Âíóòðåííèå ãëîáàëüíûå äàííûå
//
//           Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
//           Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåð, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
//           Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
//           Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé, èëè êëàññ.
//=================================================================================================================
//! @{

int                          _txInitialized              = _TX_NOINIT || _txInitialize();

volatile const unsigned      _txCanaryFirst              = 0x776F656D; // A very system value

volatile unsigned            _txMainThreadId             = 0;          // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
volatile HANDLE              _txMainThread               = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà

volatile unsigned            _txCanvas_ThreadId          = 0;          // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
volatile HANDLE              _txCanvas_Thread            = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
volatile HWND                _txCanvas_Window            = NULL;       // Äåñêðèïòîð îêíà õîëñòà TXLib

HDC                          _txCanvas_BackBuf[2]        = {NULL,      // [0] Main TXLib in-memory DC, where user's pictures lies
                                                            NULL};     // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()

RGBQUAD*                     _txCanvas_Pixels            = NULL;       // Memory buffer of _txCanvas_BackBuf[0]

HBITMAP                      _txStockBitmap              = NULL;       // Equivalent of GetStockObject (BITMAP),
                                                                       // see https://devblogs.microsoft.com/oldnewthing/20100416-00/?p=14313

CRITICAL_SECTION             _txCanvas_LockBackBuf       = {0,-1};     // Prevent simultaneous access to back buffer, see txLock()

UINT_PTR                     _txCanvas_RefreshTimer      = 1;          // Timer ID to redraw TXLib window
volatile int                 _txCanvas_RefreshLock       = 0;          // Blocks auto on-timer canvas update, see txBegin/txEnd

::std::vector<HDC>*          _txCanvas_UserDCs           = NULL;       // List of DCs allocated, for auto-free

volatile bool                _txConsole_IsBlinking       = true;       // To blink or not to blink, that is the question.

bool                         _txConsole                  = false;      // Only first TXLib module in app can own the console
bool                         _txMain                     = false;      // First TXLib wnd opened (closing it terminates program)
bool                         _txIsDll                    = false;      // TXLib module is in DLL
volatile bool                _txRunning                  = false;      // main() is still running
volatile bool                _txExit                     = false;      // exit() is active

volatile POINT               _txMousePos                 = {-1,-1};    // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
volatile unsigned            _txMouseButtons             = 0;

volatile WNDPROC             _txAltWndProc               = NULL;       // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().

_tx_thread _txLoc            _txLoc::Cur                 = {};         // Execution point tracking and trace state, see "$" macro

volatile int                 _txErrors                   = 0;          // TX_ERROR calls sequental number
int                          _txOGLError                 = 0;          // Last OpenGL error when using tx_glGetError()
volatile long                _txSENumber                 = 0;          // SEH exceptions sequental number
volatile long                _txSEFatalNumber            = 0;          // SEH fatal exceptions sequental number
char                         _txDumpSE [_TX_BUFSIZE]     = "";         // SEH dump data area
char                         _txTraceSE[_TX_HUGEBUFSIZE] = "";         // Stack trace data area

LPTOP_LEVEL_EXCEPTION_FILTER _txPrevUEFilter             = NULL;       // Previous UnhandledExceptionFilter

jmp_buf                      _txDumpExceptionObjJmp      = {};         // Hook for _txDumpExceptionObj

const volatile uintptr_t     _txForceImport[]            = { (uintptr_t) ::TerminateProcess,              (uintptr_t) ::ExitProcess,
                                                             (uintptr_t) ::FatalExit,                     (uintptr_t) ::FatalAppExitA,
                                                             (uintptr_t) ::exit,                          (uintptr_t) Win32::_controlfp,
                                                             (uintptr_t) Win32::Polyline,                 (uintptr_t) Win32::PolyBezier,
                                                             (uintptr_t) Win32::RoundRect,                (uintptr_t) Win32::RemoveVectoredExceptionHandler,
                                                             (uintptr_t) Win32::PlgBlt,                   (uintptr_t) Win32::RtlCaptureStackBackTrace,
                                                             (uintptr_t) Win32::SymInitialize,            (uintptr_t) Win32::MinGW::SymInitialize,
                                                             (uintptr_t) Win32::SymSetOptions,            (uintptr_t) Win32::MinGW::SymSetOptions,
                                                             (uintptr_t) Win32::SymGetLineFromAddr64,     (uintptr_t) Win32::MinGW::SymGetLineFromAddr64,
                                                             (uintptr_t) Win32::SymFromAddr,              (uintptr_t) Win32::MinGW::SymFromAddr,
                                                             (uintptr_t) Win32::SymCleanup,               (uintptr_t) Win32::MinGW::SymCleanup,
                                                             (uintptr_t) Win32::SymGetModuleBase64,       (uintptr_t) Win32::MinGW::SymGetModuleBase64,
                                                             (uintptr_t) Win32::SymFunctionTableAccess64, (uintptr_t) Win32::MinGW::SymFunctionTableAccess64,
                                                             (uintptr_t) Win32::StackWalk64,              (uintptr_t) Win32::MinGW::StackWalk64,
                                                             (uintptr_t) Win32::StrStrIA,                 (uintptr_t) Win32::Wow64GetThreadContext };

volatile const unsigned      _txCanaryLast               = 0x5E2E2E5E; // Another very system value

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib engine init/check/cleanup
//! @name    Èíèöèàëèçàöèÿ/ïðîâåðêà/çàâåðøåíèå TXLib
//=================================================================================================================
//! @{

//-----------------------------------------------------------------------------------------------------------------
//{          Early initialization
//-----------------------------------------------------------------------------------------------------------------

int _txInitialize()
    {
    if (_txInitialized) return 1;
    _txInitialized = 1;

    #if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)  // See http://msdn.microsoft.com/en-us/library/w2fhc9a3%28v=vs.90%29.aspx
    _CrtSetBreakAlloc (_TX_ALLOC_BREAK);                 // and http://support.microsoft.com/ru-ru/kb/151585
    #endif

    #if defined (_TX_ALLOW_TRACE)
    _txLocLvlSet (1);
    #endif

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
                                     "compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

    _txMainThreadId = GetCurrentThreadId();
    _txMainThread   = OpenThread (THREAD_ALL_ACCESS, false, _txMainThreadId);

$3  _txIsDll = _txInDll();

$   if (!_txIsDll)
        {
$       _txConsole = ! FindAtom ("_txConsole");
$       (void)          AddAtom ("_txConsole");
        }

$   if (_txConsole)
        {
$       _txCheckSourceCP (_TX_CODEPAGE, true);

$       unsigned long stackSize = _TX_STACKSIZE;
$       _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$       _txOnSignal();

$       if (!*_txLogName)
            {$ _tx_snprintf_s (_txLogName, sizeof (_txLogName) - 1, "%s.log", txGetModuleFileName()); }

$       if (!_txIsDll)
            {
$           _TX_CALL  (Win32::AddVectoredExceptionHandler, (1, (PVECTORED_EXCEPTION_HANDLER)  _txVectoredExceptionHandler));
$           _txPrevUEFilter = SetUnhandledExceptionFilter  (   (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter);
            }

$       ::std::set_terminate             (_txOnTerminate);
$       ::std::set_new_handler           (_txOnNewHandlerAnsi);
$       _TX_CALL (Win32::set_unexpected, (_txOnUnexpected));

        #if defined (_CLANG_VER) && !defined (_MSC_VER)
$       ::std::__libcpp_debug_function = _txLibCppDebugFunction;
        #endif

$       SetConsoleCtrlHandler (_txOnConsoleCtrlEvent, true);

$       SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);

        #if defined (_MSC_VER)

$       _set_printf_count_output (1);

$       _set_new_handler (_txOnNewHandler);
$       _set_new_mode (1);

        #if !defined (_CLANG_VER)

$       _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$       _CrtSetAllocHook (_txOnAllocHook);

$       unsigned mode = _CRTDBG_MODE_FILE;
$       if (_CrtSetReportHook2 (_CRT_RPTHOOK_INSTALL, (_CRT_REPORT_HOOK) _txOnErrorReport) > 0) mode = 0;

$       _CrtSetReportMode (_CRT_WARN,   _CRTDBG_MODE_DEBUG | mode);
$       _CrtSetReportMode (_CRT_ERROR,  _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportFile (_CRT_WARN,   _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ERROR,  _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);

        #endif

$       _set_abort_behavior (_WRITE_ABORT_MSG, _WRITE_ABORT_MSG);
$       _set_abort_behavior (0,                _CALL_REPORTFAULT);

$       _RTC_SetErrorFunc              (_txOnRTCFailure);
$       _set_purecall_handler          (_txOnPureCall);
$       _set_invalid_parameter_handler (_txOnInvalidParam);

        #endif

        #if defined (__STDC_LIB_EXT1__)
$       ::std::set_constraint_handler_s (_txOnSecurityErrorAnsi);
        #endif

        #if !defined (__CYGWIN__) && defined (_GCC_VER) && (_GCC_VER >= 530) && !defined (i386)
$       __setusermatherr (_txOnMatherr);
        #endif

        #if !defined (__CYGWIN__)
$       _set_error_mode (_OUT_TO_MSGBOX | _OUT_TO_STDERR);
        #endif

$       HWND console = _txConsole_Attach();
$       SetWindowTextA (console, txGetModuleFileName (false));
        }

$   InitializeCriticalSection (&_txCanvas_LockBackBuf);

$   _txSetProcAddress ("ExitProcess",                 (uintptr_t) _txOnExitProcess,                 "KERNEL32.DLL");
$   _txSetProcAddress ("TerminateProcess",            (uintptr_t) _txOnTerminateProcess,            "KERNEL32.DLL");
$   _txSetProcAddress ("FatalExit",                   (uintptr_t) _txOnFatalExit,                   "KERNEL32.DLL");
$   _txSetProcAddress ("FatalAppExitA",               (uintptr_t) _txOnFatalAppExitA,               "KERNEL32.DLL");
$   _txSetProcAddress ("UnhandledExceptionFilter",    (uintptr_t) _txUnhandledExceptionFilter,      "KERNEL32.DLL", true);
$   _txSetProcAddress ("SetUnhandledExceptionFilter", (uintptr_t) _txOnSetUnhandledExceptionFilter, "KERNEL32.DLL");
$   _txSetProcAddress ("exit",                        (uintptr_t) _txOnExit);
$   _txSetProcAddress ("_cexit",                      (uintptr_t) _txOnCExit);

$   atexit (_txCleanup);

$   if (_txConsole)
        {
$       txSetConsoleAttr (FOREGROUND_LIGHTGRAY);

$       tx_fpreset();

$       srand ((unsigned) time (NULL));

$       SetLastError (0);
$       errno = 0;

        #if !defined (__CYGWIN__)
$       _doserrno = 0;
        #endif
        }

$   HDC dc = Win32::CreateCompatibleDC (NULL); dc asserted;
$   _txStockBitmap = (HBITMAP) Win32::SelectObject (dc, Win32::CreateCompatibleBitmap (dc, 1, 1)); _txStockBitmap asserted;
$   Win32::DeleteObject (Win32::SelectObject (dc, _txStockBitmap)) asserted;
$   Win32::DeleteDC (dc) asserted;

$   return 1;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCheckSourceCP (int needCP /*= _TX_CODEPAGE*/, bool verbose /*= true*/)
    {
$3  const char* sCodePage = NULL;
$   int codePage = 0;

$   switch (((unsigned const char*) "À") [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }

$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please

$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }

$   return (codePage == needCP);
    }

//-----------------------------------------------------------------------------------------------------------------

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;

    static char dllPaths [2][MAX_PATH] = {"", ""};

    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";

        // dllPaths[0] is relative to the TX Setup directory stored in the Registry

        char* path = dllPaths[0];

        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);

        // dllPaths[1] is relative to TXib.h file used in compilation

        path = dllPaths[1];

        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }

        if (char* dir = strrchr (path, '\\')) *dir = 0;

        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }

    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);

    if (arch)
        {
        assert (arch >= dllFileName);

        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));

        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }

    HMODULE   dll = GetModuleHandle (dllFileName);

    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);

    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);

        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);

        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }

    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);

    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;

    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);

    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè
#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
    //-------------------------------------------------------------------------------------------------------------
 
    #define ID_TEXT_  101
    #define ID_INPUT_ 102
 
    //-------------------------------------------------------------------------------------------------------------
    // Çàäàíèå ìàêåòà (âèäà) äèàëîãà â âèäå ìàññèâà ñòðóêòóð.
    // Ñ ïîìîùüþ îñîáîãî ïîðÿäêà ïîëåé â ñòðóêòóðå txDialog::Layout è êîíñòàíò èç êëàññà txDialog ýòîò ìàññèâ
    // ñòàíîâèòñÿ ïîõîæ íà îïèñàíèå ðåñóðñà äèàëîãà â .rc-ôàéëå.
    // Ñì. îïèñàíèå ñèíòàêñèñà rc-ôàéëà â äîêóìåíòàöèè ïî Win32 (MSDN, http://msdn.com).
    //-------------------------------------------------------------------------------------------------------------
 
    txDialog::Layout layout[] =
 
    //----------------------+----------+-----------+-----------------+---------------------------------------------
    //     Òèï ýëåìåíòà     | Èìÿ      | Èäåíòè-   |   Êîîðäèíàòû    | Ôëàãè ýëåìåíòîâ    //     äèàëîãà          | ýëåìåíòà | ôèêàòîð   |-----------------| (ñì. îïèñàíèå ýëåìåíòîâ
    //                      |          | ýëåìåíòà  | X | Y |Øèð.|Âûñ.| îêîí äèàëîãà â MSDN)
    //----------------------+----------+-----------+---+---+----+----+---------------------------------------------
    //                      |          |           |   |   |    |    |
        {{ txDialog::DIALOG,  caption,   0,           0,  0, 240,  85                                                    },
         { txDialog::STATIC,  text,      ID_TEXT_,   10, 10, 150,  40, SS_LEFT                                           },
         { txDialog::EDIT,    input,     ID_INPUT_,  10, 60, 220,  15, ES_LEFT | WS_BORDER | ES_AUTOHSCROLL | WS_TABSTOP },
         { txDialog::BUTTON,  "&OK",     IDOK,      180, 10,  50,  15, BS_DEFPUSHBUTTON                     | WS_TABSTOP },
         { txDialog::BUTTON,  "&Cancel", IDCANCEL,  180, 30,  50,  15, BS_PUSHBUTTON                        | WS_TABSTOP },
         { txDialog::END                                                                                                 }};

    //-------------------------------------------------------------------------------------------------------------
    // Êëàññ äèàëîãà äëÿ InputBox. Âíóòðåííèé, ò.ê. çà÷åì åìó áûòü âíåøíèì.
    // Íóæåí â îñíîâíîì äëÿ çàäàíèÿ ñòðîêè ââîäà (str) è îêîííîé ôóíêöèè äèàëîãîâîãî îêíà, òðåáóåìîé Win32 (îíà
    // ïîñòðîåíà ìàêðîñàìè TX_BEGIN_MESSAGE_MAP è äðóãèìè). Ìîæíî íå äåëàòü âíóòðåííåãî êëàññà, íî òîãäà îêîííóþ
    // ôóíêöèþ ïðèäåòñÿ ïèñàòü â ãëîáàëüíîé îáëàñòè âèäèìîñòè, è str îáúÿâëÿòü ãëîáàëüíî òîæå (èëè ïåðåäàâàòü åå
    // àäðåñ ÷åðåç DialogBoxParam è çàïèñûâàòü åãî â êëàññ âî âðåìÿ îáðàáîòêè WM_INITDIALOG).
    //-------------------------------------------------------------------------------------------------------------
    struct inputDlg : txDialog
        {
        char str [1024];

        //---------------------------------------------------------------------------------------------------------

        inputDlg() :
            str()
            {}

        //---------------------------------------------------------------------------------------------------------

        TX_BEGIN_MESSAGE_MAP()    // Êàðòà ñîîáùåíèé (íà ñàìîì äåëå ýòî íà÷àëî îêîííîé ôóíêöèè).

            TX_COMMAND_MAP        // Çäåñü îáðàáàòûâàþòñÿ WM_COMMAND (íà ñàìîì äåëå ýòî îïåðàòîð switch).

                //-------------------------------------------------------------------------------------------------
                // Ïðè íàæàòèè êíîïêè OK êîïèðóåì ñòðîêó èç ïîëÿ ââîäà â íàøó ïåðåìåííóþ str, ò.ê. ïîñëå çàêðûòèÿ
                // äèàëîãà ñòðîêà ââîäà óìðåò è òåêñò óæå èç íåå ïîëó÷èòü.
                // Ýòîò ìàêðîñ íà ñàìîì äåëå ïðåâðàùàåòñÿ â case èç îïåðàòîðà switch.
                // _wnd -- ýòî ïàðàìåòð îêîííîé ôóíêöèè, ñì. îïðåäåëåíèå ìàêðîñà TX_BEGIN_MESSAGE_MAP().
                //-------------------------------------------------------------------------------------------------

                TX_HANDLE (IDOK) GetDlgItemText (_wnd, ID_INPUT_, str, sizeof (str) - 1);

        TX_END_MESSAGE_MAP

        //---------------------------------------------------------------------------------------------------------
        // Êîíåö âíóòðåííåãî êëàññà äèàëîãà
        //---------------------------------------------------------------------------------------------------------
        };

    //-------------------------------------------------------------------------------------------------------------
    // Óáèðàåì äåôàéíû, ÷òîáû ïîòîì íå ìåøàëè.
    // Îò ýòîãî îíè ïîëó÷àþòñÿ "ëîêàëüíîãî äåéñòâèÿ", êàê áóäòî ó íèõ áûëà áû îáëàñòü âèäèìîñòè -- ôóíêöèÿ. Íà ñàìîì
    // äåëå ýòî ñäåëàíî âðó÷íóþ ÷åðåç #undef. ×òîáû ïîä÷åðêíóòü èõ ëîêàëüíóþ ïðèðîäó, ó íèõ èìåíà çàêàí÷èâàþòñÿ íà _.
    // Òàêèå äåôàéíû ïîòîì íå ïåðåêîñÿ÷àò âåñü êîä ïîñëå òîãî êàê, ôàêòè÷åñêè, ñòàëè óæå íå íóæíû.
    //-------------------------------------------------------------------------------------------------------------

    #undef ID_TEXT_
    #undef ID_INPUT_

    //-------------------------------------------------------------------------------------------------------------
    // Ýòî ñòàòè÷åñêèé îáúåêò, ïîòîìó ÷òî ñòðîêà â íåì äîëæíà æèòü ïîñëå çàâåðøåíèÿ ôóíêöèè.
    //-------------------------------------------------------------------------------------------------------------

    static inputDlg dlg;

    //-------------------------------------------------------------------------------------------------------------
    // Ïåðåäàåì layout è çàïóñêàåì îêíî äèàëîãà
    //-------------------------------------------------------------------------------------------------------------

    dlg.dialogBox (layout);

    //-------------------------------------------------------------------------------------------------------------
    // Âîçâðàùàåì àäðåñ ñòðîêè èç ñòàòè÷åñêîãî îáúåêòà. Òàê ìîæíî äåëàòü, ïîòîìó ÷òî ñòàòè÷åñêèé îáúåêò íå óìðåò
    // ïðè âûõîäå èç ôóíêöèè è ñòðîêà â íåì, ñîîòâåòñòâåííî, òîæå. Àäðåñ íåñòàòè÷åñêèõ ïåðåìåííûõ ïåðåäàâàòü
    // ñèíòàêñè÷åñêè ìîæíî, íî âåäåò ê ñåðüåçíûì îøèáêàì.
    //-------------------------------------------------------------------------------------------------------------

    return dlg.str;
    }

//! @}
//}
//=================================================================================================================

//}
//=================================================================================================================

//=================================================================================================================
//{          TXLIB IMPLEMENTATION
//           Ðåàëèçàöèÿ ôóíêöèé áèáëèîòåêè
//=================================================================================================================
//! @cond INTERNAL

//=================================================================================================================
//{          DLL functions import, missing types definitions
//! @name    Èìïîðò âíåøíèõ áèáëèîòåê, îïðåäåëåíèå íåäîñòàþùèõ òèïîâ
//=================================================================================================================
//! @{

namespace Win32 {

//-----------------------------------------------------------------------------------------------------------------
//{ Some of structs, consts and interfaces aren't defined in MinGW some early headers.
//  Copied from Windows SDK 7.0a.
//-----------------------------------------------------------------------------------------------------------------

#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                             0x01
#endif

#ifndef SMTO_ERRORONEXIT
#define SMTO_ERRORONEXIT                         0x0020
#endif

#ifndef NT_CONSOLE_PROPS_SIG
#define NT_CONSOLE_PROPS_SIG                     0xA0000002
#endif

#ifndef NIIF_INFO
#define NIIF_INFO                                0x00000001
#define NIIF_WARNING                             0x00000002
#define NIIF_ERROR                               0x00000003
#endif

#ifndef NIF_INFO
#define NIF_STATE                                0x00000008
#define NIF_INFO                                 0x00000010
#endif

#ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
#define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS   0x00000004
#endif

#ifndef SYMOPT_CASE_INSENSITIVE
#define SYMOPT_CASE_INSENSITIVE                  0x00000001
#define SYMOPT_UNDNAME                           0x00000002
#define SYMOPT_DEFERRED_LOADS                    0x00000004
#define SYMOPT_NO_CPP                            0x00000008
#define SYMOPT_LOAD_LINES                        0x00000010
#define SYMOPT_OMAP_FIND_NEAREST                 0x00000020
#define SYMOPT_LOAD_ANYTHING                     0x00000040
#define SYMOPT_IGNORE_CVREC                      0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS              0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS              0x00000200
#define SYMOPT_EXACT_SYMBOLS                     0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS            0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH                 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES             0x00002000
#define SYMOPT_PUBLICS_ONLY                      0x00004000
#define SYMOPT_NO_PUBLICS                        0x00008000
#define SYMOPT_AUTO_PUBLICS                      0x00010000
#define SYMOPT_NO_IMAGE_SEARCH                   0x00020000
#define SYMOPT_SECURE                            0x00040000
#define SYMOPT_NO_PROMPTS                        0x00080000
#define SYMOPT_ALLOW_ZERO_ADDRESS                0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT         0x02000000
#define SYMOPT_FAVOR_COMPRESSED                  0x00800000
#define SYMOPT_FLAT_DIRECTORY                    0x00400000
#define SYMOPT_IGNORE_IMAGEDIR                   0x00200000
#define SYMOPT_OVERWRITE                         0x00100000
#define SYMOPT_DEBUG                             0x80000000
#endif

// SEH exception codes. For GCC, see http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 64-66.

#ifndef STATUS_POSSIBLE_DEADLOCK
#define STATUS_POSSIBLE_DEADLOCK                 0xC0000194
#endif

#ifndef STATUS_FLOAT_MULTIPLE_FAULTS
#define STATUS_FLOAT_MULTIPLE_FAULTS             0xC00002B4
#endif

#ifndef STATUS_STACK_BUFFER_OVERRUN
#define STATUS_STACK_BUFFER_OVERRUN              0xC0000409
#endif

#ifndef STATUS_ASSERTION_FAILURE
#define STATUS_ASSERTION_FAILURE                 0xC0000420
#endif

#ifndef STATUS_WX86_BREAKPOINT
#define STATUS_WX86_BREAKPOINT                   0x4000001F
#endif

#ifndef DBG_PRINTEXCEPTION_C
#define DBG_PRINTEXCEPTION_C                     0x40010006  // OutputDebugStringA() call
#endif

#ifndef DBG_PRINTEXCEPTION_WIDE_C
#define DBG_PRINTEXCEPTION_WIDE_C                0x4001000A  // OutputDebugStringW() call
#endif

#ifndef DBG_THREAD_NAME
#define DBG_THREAD_NAME                          0x406D1388
#endif

#define EXCEPTION_CPP_MSC                        0xE06D7363  // '?msc'
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1       0x19930520  // '?msc' version magic, see ehdata.h
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2       0x19930521  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3       0x19930522  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1  0x01994000  // '?msc' version magic

#define EXCEPTION_CPP_GCC                        0x20474343  // ' GCC'
#define EXCEPTION_CPP_GCC_UNWIND                 0x21474343  // '!GCC'
#define EXCEPTION_CPP_GCC_FORCED                 0x22474343  // '"GCC'

#define EXCEPTION_CLR_FAILURE                    0xE0434f4D  // 'àCOM'

#define EXCEPTION_CPP_BORLAND_BUILDER            0x0EEDFAE6  // Should never occur here
#define EXCEPTION_CPP_BORLAND_DELPHI             0x0EEDFADE  // Should never occur here

#pragma pack (push, 1)

struct CONSOLE_CURSOR_INFO
    {
    DWORD dwSize;
    BOOL bVisible;
    };

struct CONSOLE_FONT_INFO
    {
    DWORD nFont;
    COORD dwFontSize;
    };

struct CONSOLE_FONT_INFOEX
    {
    ULONG cbSize;
    DWORD nFont;
    COORD dwFontSize;
    UINT  FontFamily;
    UINT  FontWeight;
    WCHAR FaceName[LF_FACESIZE];
    };

struct DATABLOCK_HEADER
    {
    DWORD cbSize;
    DWORD dwSignature;
    };

struct NT_CONSOLE_PROPS
    {
    DATABLOCK_HEADER dbh;

    WORD  wFillAttribute;
    WORD  wPopupFillAttribute;
    COORD dwScreenBufferSize;
    COORD dwWindowSize;
    COORD dwWindowOrigin;
    DWORD nFont;
    DWORD nInputBufferSize;
    COORD dwFontSize;
    UINT  uFontFamily;
    UINT  uFontWeight;
    WCHAR FaceName[LF_FACESIZE];
    UINT  uCursorSize;
    BOOL  bFullScreen;
    BOOL  bQuickEdit;
    BOOL  bInsertMode;
    BOOL  bAutoPosition;
    UINT  uHistoryBufferSize;
    UINT  uNumberOfHistoryBuffers;
    BOOL  bHistoryNoDup;

    COLORREF ColorTable[16];
    };

#pragma pack (pop)

#undef  INTERFACE
#define INTERFACE IShellLinkDataList

DECLARE_INTERFACE_ (IShellLinkDataList, IUnknown)
    {
    // *** IUnknown methods ***
    STDMETHOD (QueryInterface)  (THIS_ REFIID iid, void** value)    _tx_override PURE;
    STDMETHOD_(ULONG, AddRef)   (THIS)                              _tx_override PURE;
    STDMETHOD_(ULONG, Release)  (THIS)                              _tx_override PURE;

    // *** IShellLinkDataList methods ***
    STDMETHOD (AddDataBlock)    (THIS_ void* dataBlock)             PURE;
    STDMETHOD (CopyDataBlock)   (THIS_ DWORD sig, void** dataBlock) PURE;
    STDMETHOD (RemoveDataBlock) (THIS_ DWORD sig)                   PURE;
    STDMETHOD (GetFlags)        (THIS_ DWORD* flags)                PURE;
    STDMETHOD (SetFlags)        (THIS_ DWORD  flags)                PURE;

    protected:
    virtual ~IShellLinkDataList();
    };

const GUID IID_IShellLink         = {0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID IID_IShellLinkDataList = {0x45e2b4ae, 0xb1c3, 0x11d0, {0xb9,0x2f,0x00,0xa0,0xc9,0x03,0x12,0xe1}};
const GUID IID_IPersistFile       = {0x0000010b, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};

const GUID CLSID_SpVoice          = {0x96749377, 0x3391, 0x11d2, {0x9e,0xe3,0x00,0xc0,0x4f,0x79,0x73,0x96}};
const GUID IID_ISpVoice           = {0x6c44df74, 0x72b9, 0x4992, {0xa1,0xec,0xef,0x99,0x6e,0x04,0x22,0xd4}};

#undef  INTERFACE

typedef DWORD     NTSTATUS;
typedef ULONG_PTR KAFFINITY;
typedef LONG      KPRIORITY;

struct UNICODE_STRING
    {
    USHORT Length;
    USHORT MaximumLength;
    WCHAR* Buffer;
    };

struct RTL_USER_PROCESS_PARAMETERS
    {
    BYTE  Reserved1[16];
    void* Reserved2[10];
    UNICODE_STRING ImagePathName;
    UNICODE_STRING CommandLine;
    };

struct PEB
    {
    BYTE  Reserved1[2];
    BYTE  BeingDebugged;
    BYTE  Reserved2[1];
    void* Reserved3[2];
    void* Ldr;
    RTL_USER_PROCESS_PARAMETERS* ProcessParameters;
    void* Reserved4[3];
    void* AtlThunkSListPtr;
    void* Reserved5;
    ULONG Reserved6;
    void* Reserved7;
    ULONG Reserved8;
    ULONG AtlThunkSListPtr32;
    void* Reserved9[45];
    BYTE  Reserved10[96];
    void* PostProcessInitRoutine;
    BYTE  Reserved11[128];
    void* Reserved12[1];
    ULONG SessionId;
    };

struct PROCESS_BASIC_INFORMATION
    {
    NTSTATUS  ExitStatus;
    PEB*      PebBaseAddress;
    KAFFINITY AffinityMask;
    KPRIORITY BasePriority;
    ULONG_PTR UniqueProcessId;
    ULONG_PTR InheritedFromUniqueProcessId;
    };

enum ADDRESS_MODE
    {
    AddrMode1616,
    AddrMode1632,
    AddrModeReal,
    AddrModeFlat
    };

struct ADDRESS64
    {
    DWORD64      Offset;
    WORD         Segment;
    ADDRESS_MODE Mode;
    };

struct KDHELP64
    {
    DWORD64 Thread;
    DWORD   ThCallbackStack;
    DWORD   ThCallbackBStore;
    DWORD   NextCallback;
    DWORD   FramePointer;
    DWORD64 KiCallUserMode;
    DWORD64 KeUserCallbackDispatcher;
    DWORD64 SystemRangeStart;
    DWORD64 KiUserExceptionDispatcher;
    DWORD64 StackBase;
    DWORD64 StackLimit;
    DWORD64 Reserved[5];
    };

struct STACKFRAME64
    {
    ADDRESS64 AddrPC;
    ADDRESS64 AddrReturn;
    ADDRESS64 AddrFrame;
    ADDRESS64 AddrStack;
    ADDRESS64 AddrBStore;
    PVOID     FuncTableEntry;
    DWORD64   Params[4];
    BOOL      Far;
    BOOL      Virtual;
    DWORD64   Reserved[3];
    KDHELP64  KdHelp;
    };

struct WOW64_FLOATING_SAVE_AREA
    {
    DWORD ControlWord;
    DWORD StatusWord;
    DWORD TagWord;
    DWORD ErrorOffset;
    DWORD ErrorSelector;
    DWORD DataOffset;
    DWORD DataSelector;
    BYTE  RegisterArea[80];
    DWORD Cr0NpxState;
    };

#pragma pack (push, 4)

struct WOW64_CONTEXT
    {
    DWORD ContextFlags;

    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;

    WOW64_FLOATING_SAVE_AREA FloatSave;

    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;

    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;

    DWORD Ebp;
    DWORD Eip;
    DWORD SegCs;
    DWORD EFlags;
    DWORD Esp;
    DWORD SegSs;

    BYTE  ExtendedRegisters[512];
    };

#pragma pack (pop)

struct SYMBOL_INFO
    {
    ULONG   SizeOfStruct;
    ULONG   TypeIndex;
    ULONG64 Reserved[2];
    ULONG   info;
    ULONG   Size;
    ULONG64 ModBase;
    ULONG   Flags;
    ULONG64 Value;
    ULONG64 Address;
    ULONG   Register;
    ULONG   Scope;
    ULONG   Tag;
    ULONG   NameLen;
    ULONG   MaxNameLen;
    CHAR    Name[1];
    };

struct IMAGEHLP_LINE64
    {
    DWORD   SizeOfStruct;
    PVOID   Key;
    DWORD   LineNumber;
    PCHAR   FileName;
    DWORD64 Address;
    };

typedef bool    (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)   (HANDLE process, DWORD64 baseAddress, void* buffer, DWORD size, DWORD* bytesRead);
typedef void*   (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64) (HANDLE process, DWORD64 baseAddress);
typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)       (HANDLE process, DWORD64 address);
typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)     (HANDLE process, HANDLE thread, ADDRESS64* address);

typedef void (*unexpected_handler)();

#pragma pack (push, 4)

struct MINIDUMP_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    };

struct MINIDUMP_THREAD_EX_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    ULONG64  BackingStoreBase;
    ULONG64  BackingStoreEnd;
    };

struct MINIDUMP_MODULE_CALLBACK
    {
    wchar_t* FullPath;
    ULONG64  BaseOfImage;
    ULONG    SizeOfImage;
    ULONG    CheckSum;
    ULONG    TimeDateStamp;
    VS_FIXEDFILEINFO VersionInfo;
    void*    CvRecord;
    ULONG    SizeOfCvRecord;
    PVOID    MiscRecord;
    ULONG    SizeOfMiscRecord;
    };

struct MINIDUMP_INCLUDE_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    };

struct MINIDUMP_INCLUDE_MODULE_CALLBACK
    {
    ULONG64  BaseOfImage;
    };

struct MINIDUMP_MEMORY_INFO
    {
    ULONG64  BaseAddress;
    ULONG64  AllocationBase;
    ULONG32  AllocationProtect;
    ULONG32  __alignment1;
    ULONG64  RegionSize;
    ULONG32  State;
    ULONG32  Protect;
    ULONG32  Type;
    ULONG32  __alignment2;
    };

struct MINIDUMP_USER_STREAM
    {
    ULONG32  Type;
    ULONG    BufferSize;
    PVOID    Buffer;
    };

struct MINIDUMP_USER_STREAM_INFORMATION
    {
    ULONG                 UserStreamCount;
    MINIDUMP_USER_STREAM* UserStreamArray;
    };

struct MINIDUMP_CALLBACK_INPUT
    {
    ULONG    ProcessId;
    HANDLE   ProcessHandle;
    ULONG    CallbackType;

    union
        {
        MINIDUMP_THREAD_CALLBACK         Thread;
        MINIDUMP_THREAD_EX_CALLBACK      ThreadEx;
        MINIDUMP_MODULE_CALLBACK         Module;
        MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
        MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
        };
    };

struct MINIDUMP_CALLBACK_OUTPUT
    {
    union
        {
        ULONG ModuleWriteFlags;
        ULONG ThreadWriteFlags;
        ULONG SecondaryFlags;

        struct
            {
            ULONG64  MemoryBase;
            ULONG    MemorySize;
            };

        struct
            {
            unsigned CheckCancel;
            unsigned Cancel;
            };

        HANDLE Handle;
        };

    struct
        {
        MINIDUMP_MEMORY_INFO VmRegion;
        unsigned             Continue;
        };

    HRESULT Status;
    };

struct MINIDUMP_EXCEPTION_INFORMATION
    {
    DWORD               ThreadId;
    EXCEPTION_POINTERS* ExceptionPointers;
    unsigned            ClientPointers;
    };

typedef int (WINAPI* MINIDUMP_CALLBACK_ROUTINE) (void* param, MINIDUMP_CALLBACK_INPUT* input, MINIDUMP_CALLBACK_OUTPUT* output);

struct MINIDUMP_CALLBACK_INFORMATION
    {
    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
    void*                     CallbackParam;
    };

enum MINIDUMP_TYPE
    {
    MiniDumpNormal                         = 0x00000000,
    MiniDumpWithDataSegs                   = 0x00000001,
    MiniDumpWithFullMemory                 = 0x00000002,
    MiniDumpWithHandleData                 = 0x00000004,
    MiniDumpFilterMemory                   = 0x00000008,
    MiniDumpScanMemory                     = 0x00000010,
    MiniDumpWithUnloadedModules            = 0x00000020,
    MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
    MiniDumpFilterModulePaths              = 0x00000080,
    MiniDumpWithProcessThreadData          = 0x00000100,
    MiniDumpWithPrivateReadWriteMemory     = 0x00000200,
    MiniDumpWithoutOptionalData            = 0x00000400,
    MiniDumpWithFullMemoryInfo             = 0x00000800,
    MiniDumpWithThreadInfo                 = 0x00001000,
    MiniDumpWithCodeSegs                   = 0x00002000,
    MiniDumpWithoutAuxiliaryState          = 0x00004000,
    MiniDumpWithFullAuxiliaryState         = 0x00008000,
    MiniDumpWithPrivateWriteCopyMemory     = 0x00010000,
    MiniDumpIgnoreInaccessibleMemory       = 0x00020000,
    MiniDumpWithTokenInformation           = 0x00040000
    };

#pragma pack (pop)

#define FOREGROUND_BLACK         ( 0                                                         )
#define FOREGROUND_CYAN          ( FOREGROUND_BLUE       | FOREGROUND_GREEN                  )
#define FOREGROUND_MAGENTA       ( FOREGROUND_BLUE       | FOREGROUND_RED                    )
#define FOREGROUND_DARKYELLOW    ( FOREGROUND_GREEN      | FOREGROUND_RED                    )
#define FOREGROUND_LIGHTGRAY     ( FOREGROUND_BLUE       | FOREGROUND_GREEN | FOREGROUND_RED )
#define FOREGROUND_DARKGRAY      (                         FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTBLUE     ( FOREGROUND_BLUE       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTGREEN    ( FOREGROUND_GREEN      | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTCYAN     ( FOREGROUND_CYAN       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTRED      ( FOREGROUND_RED        | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTMAGENTA  ( FOREGROUND_MAGENTA    | FOREGROUND_INTENSITY              )
#define FOREGROUND_YELLOW        ( FOREGROUND_DARKYELLOW | FOREGROUND_INTENSITY              )
#define FOREGROUND_WHITE         ( FOREGROUND_LIGHTGRAY  | FOREGROUND_INTENSITY              )

#define BACKGROUND_BLACK         ( 0                                                         )
#define BACKGROUND_CYAN          ( BACKGROUND_BLUE       | BACKGROUND_GREEN                  )
#define BACKGROUND_MAGENTA       ( BACKGROUND_BLUE       | BACKGROUND_RED                    )
#define BACKGROUND_DARKYELLOW    ( BACKGROUND_GREEN      | BACKGROUND_RED                    )
#define BACKGROUND_GRAY          ( BACKGROUND_BLUE       | BACKGROUND_GREEN | BACKGROUND_RED )
#define BACKGROUND_DARKGRAY      (                         BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTBLUE     ( BACKGROUND_BLUE       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTGREEN    ( BACKGROUND_GREEN      | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTCYAN     ( BACKGROUND_CYAN       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTRED      ( BACKGROUND_RED        | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTMAGENTA  ( BACKGROUND_MAGENTA    | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTYELLOW   ( BACKGROUND_DARKYELLOW | BACKGROUND_INTENSITY              )
#define BACKGROUND_WHITE         ( BACKGROUND_DARKGRAY   | BACKGROUND_INTENSITY              )

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ There are copies of MSVC compiler built-in predefined definitions, which are wrong in 64-bit mode.
//  So we have to override them. See: http://stackoverflow.com/questions/39113168
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)
                                                    //  MS ABI C++ Exception Layout
namespace Win32 {                                   //  ---------------------------
                                                    //
#pragma pack (push, 4)                              //   EXCEPTION_RECORD:
                                                    //  +==================================================+
struct ThrowInfo                                    //  |...                                               |
    {                                               //  |NumberParameters:        3, 4 or more             |
    __int32 attributes;                             //  |ExceptionInformation[0]: MS signature 0x19930520  |
    __int32 pmfnUnwind;                             //  |ExceptionInformation[1]: object* thrown           |
    __int32 pForwardCompat;                         //  |ExceptionInformation[2]: ThrowInfo* --------------+---+
    __int32 pCatchableTypeArray;                    //  |ExceptionInformation[3]: ImageBase (if params > 3)|   |
    };                                              //  +==================================================+   |
                                                    //                                                         |
struct CatchableTypeArray                           //        ThrowInfo:                                       |
    {                                               //        +======================================+ <-------+
    __int32 nCatchableTypes;                        //        |   ...                                |
    __int32 arrayOfCatchableTypes[];                //  +-----+-- pCatchableTypeArray (ptr/RVA)      |
    };                                              //  |     +======================================+
                                                    //  |
struct CatchableType                                //  |     CatchableTypeArray:
    {                                               //  +---> +======================================+
    __int32 properties;                             //        |   ...                                |
    __int32 pType;                                  //  +-----+-- arrayOfCatchableTypes[0] (ptr/RVA) |
    __int32 thisDisplacement[3]; // struct _PMD     //  |     +======================================+
    __int32 sizeOrOffset;                           //  |
    __int32 copyFunction;                           //  |     CatchableType:
    };                                              //  +---> +====================+
                                                    //        | ...                |        std::type_info:
#pragma pack (pop)                                  //        | pType (ptr/RVA) ---+------> +==================+
                                                    //        | ...                |        |type_info data    |
} // namespace Win32                                //        +====================+        |...               |
                                                    //                                      +==================+
#endif

// Similar to __CxxDetectRethrow(), see C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\crtsrc\vcruntime\frame.cpp:

#define _TX_MSC__CXX_DETECT_RETHROW( exc )                                     \
    (                                                                          \
    (exc)                                          &&                          \
    (exc) -> ExceptionCode    == EXCEPTION_CPP_MSC &&                          \
    (exc) -> NumberParameters >= 3                 &&                          \
                                                                               \
    ((exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3) && \
                                                                               \
    (exc) -> ExceptionInformation[2] == 0                                      \
    )

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ The corresponding structures for GCC
//
//  From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/unwind-cxx.h
//  See:  http://mentorembedded.github.io/cxx-abi/abi-eh.html#cxx-abi
//-----------------------------------------------------------------------------------------------------------------

#if defined (_GCC_VER)
                                                    // GCC ABI C++ Exception layout. A/B are ExceptionInformation[0].
namespace ABI {                                     // --------------------------------------------------------------
                                                    //
struct __cxa_exception                              // Case A: "_Unwind_Exception* A" is undependent exception:
    {                                               // --------------------------------------------------------
    union {                                         //
        struct                                      //           __cxa_exception:           std::type_info:
            {                                       //       -*--+====================+     +==================+
            ::std::type_info* exceptionType;        //        ^  |exceptionType* -----+---->|type_info data    |
            void (*exceptionDestructor)(void*);     //        |  |...                 |     |...               |
            };                                      //       -1  |                    |     +==================+
        struct                                      //        |  |                    |
            {                                       // A >----|--+--------------------+
            __cxa_exception*  primaryException;     //     |  |  |unwindHeader        |
            void (*padding)();                      //    +1  |  |                    |
            };                                      //     |  |  |                    |
        };                                          //     V  |  |                    |
                                                    //    -*---  +====================+
    std::unexpected_handler   unexpectedHandler;    //           |object              |
    std::terminate_handler    terminateHandler;     //           +--------------------+
                                                    //
    __cxa_exception*          nextException;        // Case B: "_Unwind_Exception* B" is dependent exception
    int                       handlerCount;         // (unwindHeader.exception_class & 1 != 0):
    int                       handlerSwitchValue;   // -----------------------------------------------------
    const unsigned char*      actionRecord;         //
    const unsigned char*      languageSpecificData; //           __cxa_exception:               __cxa_exception:
    void*                     catchTemp;            //       -*--+====================+     -*--+=================+
    void*                     adjustedPtr;          //        ^  |primaryException* --+--    ^  |exceptionType*   |
                                                    //        |  |...                 |  \   |  |...              |
    _Unwind_Exception         unwindHeader;         //       -1  |                    |  |   |  |                 |
    };                                              //        |  |                    |  |   |  |                 |
                                                    // B >----|--+--------------------+  |  -1  +-----------------+
struct __cxa_eh_globals                             //     |  |  |unwindHeader        |  |   |  |unwindHeader     |
    {                                               //    +1  |  |                    |  |   |  |                 |
    __cxa_exception* caughtExceptions;              //     |  |  |                    |  |   |  |                 |
    unsigned int     uncaughtExceptions;            //     V  |  |                    |  \   |  |                 |
    };                                              //    -*---  +====================+   -->*--+=================+
                                                    //           |...                 |         |object           |
} // namespace ABI                                  //           .                    .         |                 |
                                                    //                                          +-----------------+

extern "C" ABI::__cxa_eh_globals* __cxa_get_globals();

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ Hand-made IAT.
//  Some IDEs don't link with these libs by default in console projects, so do sunrise by hand. :(
//-----------------------------------------------------------------------------------------------------------------

// Hand-made DLLIMPORT helpers

#define _TX_DLLIMPORT(     lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, true)

#define _TX_DLLIMPORT_OPT( lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, false)

#define _TX_DLLIMPORT_CRT( lib, retval, name, params ) \
     retval (      * name) params = (retval (      *) params) _txDllImport (lib ".dll", #name, false)

typedef void (*_tx_FARPROC)();

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required = true);

//-----------------------------------------------------------------------------------------------------------------

namespace Win32 {

_TX_DLLIMPORT     ("GDI32",    HDC,      CreateCompatibleDC,            (HDC dc));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateCompatibleBitmap,        (HDC dc, int width, int height));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetStockObject,                (int object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  SelectObject,                  (HDC dc, HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetCurrentObject,              (HDC dc, unsigned objectType));
_TX_DLLIMPORT     ("GDI32",    int,      GetObjectA,                    (HGDIOBJ obj, int bufsize, void* buffer));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GetObjectType,                 (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteDC,                      (HDC dc));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteObject,                  (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetTextColor,                  (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetBkColor,                    (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    int,      SetBkMode,                     (HDC dc, int bkMode));
_TX_DLLIMPORT     ("GDI32",    HFONT,    CreateFontA,                   (int height, int width, int escapement, int orientation,
                                                                         int weight, DWORD italic, DWORD underline, DWORD strikeout,
                                                                         DWORD charSet, DWORD outputPrec, DWORD clipPrec,
                                                                         DWORD quality, DWORD pitchAndFamily, const char face[]));
_TX_DLLIMPORT     ("GDI32",    int,      EnumFontFamiliesExA,           (HDC dc, LPLOGFONT logFont, FONTENUMPROC enumProc,
                                                                         LPARAM lParam, DWORD reserved));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetPixel,                      (HDC dc, int x, int y, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, GetPixel,                      (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    HPEN,     CreatePen,                     (int penStyle, int width, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    HBRUSH,   CreateSolidBrush,              (COLORREF color));
_TX_DLLIMPORT     ("GDI32",    bool,     MoveToEx,                      (HDC dc, int x, int y, POINT* point));
_TX_DLLIMPORT     ("GDI32",    bool,     LineTo,                        (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    bool,     Polygon,                       (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Polyline,                      (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     PolyBezier,                    (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Rectangle,                     (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     RoundRect,                     (HDC dc, int x0, int y0, int x1, int y1, int sizeX, int sizeY));
_TX_DLLIMPORT     ("GDI32",    bool,     Ellipse,                       (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     Arc,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Pie,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Chord,                         (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     TextOutA,                      (HDC dc, int x, int y, const char string[], int length));
_TX_DLLIMPORT     ("GDI32",    UINT,     SetTextAlign,                  (HDC dc, unsigned mode));
_TX_DLLIMPORT     ("GDI32",    bool,     GetTextExtentPoint32A,         (HDC dc, const char string[], int length, SIZE* size));
_TX_DLLIMPORT     ("GDI32",    bool,     ExtFloodFill,                  (HDC dc, int x, int y, COLORREF color, unsigned type));
_TX_DLLIMPORT     ("GDI32",    bool,     BitBlt,                        (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src,  int xSrc,  int ySrc,  DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     StretchBlt,                    (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src, int xSrc, int ySrc, int wSrc, int hSrc, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     PlgBlt,                        (HDC dest, const POINT* parallelogram,
                                                                         HDC src, int xSrc, int ySrc, int width, int height,
                                                                         HBITMAP mask, int xMask, int yMask));
_TX_DLLIMPORT     ("GDI32",    int,      SetDIBitsToDevice,             (HDC dc, int xDest, int yDest, DWORD width, DWORD height,
                                                                         int xSrc, int ySrc, unsigned startLine, unsigned numLines,
                                                                         const void* data, const BITMAPINFO* info, unsigned colorUse));
_TX_DLLIMPORT     ("GDI32",    int,      GetDIBits,                     (HDC hdc, HBITMAP hbmp, unsigned uStartScan, unsigned cScanLines,
                                                                         void* lpvBits, BITMAPINFO* lpbi, unsigned usage));
_TX_DLLIMPORT     ("GDI32",    bool,     PatBlt,                        (HDC dc, int x0, int y0, int width, int height, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    int,      SetROP2,                       (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    int,      SetStretchBltMode,             (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GdiSetBatchLimit,              (DWORD limit));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateDIBSection,              (HDC dc, const BITMAPINFO* bmInfo, unsigned colorUsage, void **vBits,
                                                                         HANDLE section, DWORD offset));

_TX_DLLIMPORT     ("User32",   int,      DrawTextA,                     (HDC dc, const char text[], int length, RECT* rect, unsigned format));
_TX_DLLIMPORT     ("User32",   HANDLE,   LoadImageA,                    (HINSTANCE inst, const char name[], unsigned type,
                                                                        int sizex, int sizey, unsigned mode));
_TX_DLLIMPORT_OPT ("User32",   bool,     IsHungAppWindow,               (HWND wnd));
_TX_DLLIMPORT_OPT ("User32",   HWND,     GhostWindowFromHungWindow,     (HWND wnd));

_TX_DLLIMPORT     ("WinMM",    bool,     PlaySound,                     (const char sound[], HMODULE mod, DWORD mode));

_TX_DLLIMPORT_OPT ("MSImg32",  bool,     TransparentBlt,                (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         unsigned transparentColor));
_TX_DLLIMPORT_OPT ("MSImg32",  bool,     AlphaBlend,                    (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         BLENDFUNCTION blending));

_TX_DLLIMPORT     ("Kernel32", void,     ExitProcess,                   (unsigned retcode));
_TX_DLLIMPORT     ("Kernel32", bool,     TerminateProcess,              (HANDLE process, unsigned retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalExit,                     (int retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalAppExitA,                 (unsigned action, const char message[]));
_TX_DLLIMPORT     ("Kernel32", HWND,     GetConsoleWindow,              (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetConsoleFont,                (HANDLE con, DWORD fontIndex));
_TX_DLLIMPORT_OPT ("Kernel32", DWORD,    GetNumberOfConsoleFonts,       (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFont,         (HANDLE con, bool maxWnd, CONSOLE_FONT_INFO*   curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", void,     RtlCaptureContext,             (CONTEXT* contextRecord));
_TX_DLLIMPORT_OPT ("Kernel32", USHORT,   RtlCaptureStackBackTrace,      (DWORD framesToSkip, DWORD framesToCapture, void** backTrace, DWORD* hash));
_TX_DLLIMPORT_OPT ("Kernel32", void*,    AddVectoredExceptionHandler,   (unsigned long firstHandler, PVECTORED_EXCEPTION_HANDLER handler));
_TX_DLLIMPORT_OPT ("Kernel32", unsigned, RemoveVectoredExceptionHandler,(void* handler));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetModuleHandleEx,             (DWORD flags, const char moduleName[], HMODULE* module));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     IsWow64Process,                (HANDLE process, int* isWow64Process));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     Wow64GetThreadContext,         (HANDLE thread, WOW64_CONTEXT* context));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetThreadStackGuarantee,       (unsigned long* stackSize));

_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoInitialize,                  (void*));
_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoCreateInstance,              (REFCLSID clsId, IUnknown*, DWORD, REFIID iId, PVOID* value));
_TX_DLLIMPORT     ("OLE32",    void,     CoUninitialize,                (void));

_TX_DLLIMPORT     ("Shell32",  HINSTANCE,ShellExecuteA,                 (HWND wnd, const char operation[], const char file[],
                                                                         const char parameters[], const char directory[], int showCmd));

_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIA,                      (const char    string[], const char    search[]));
_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIW,                      (const wchar_t string[], const wchar_t search[]));

_TX_DLLIMPORT_OPT ("NTDLL",    char*,    wine_get_version,              (void));
_TX_DLLIMPORT     ("NTDLL",    NTSTATUS, NtQueryInformationProcess,     (HANDLE process, int infoClass,
                                                                         void* processInfo, unsigned long szProcessInfo, unsigned long* szReturnInfo));

_TX_DLLIMPORT_CRT ("MSVCRT",   void,     exit,                          (int retcode));
_TX_DLLIMPORT_CRT ("MSVCRT",   void,     _cexit,                        (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _fpreset,                      (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _controlfp,                    (unsigned control, unsigned mask));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthread,                  (void (__cdecl* start_address) (void*), unsigned stack_size, void* arglist));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthreadex,                (void* security, unsigned stack_size, unsigned (__stdcall* start_address) (void*),
                                                                         void *arglist, unsigned init_flag, unsigned* thread_addr));
_TX_DLLIMPORT_CRT ("MSVCRT",   char*,    __unDName,                     (char* outStr, const char* mangledName, int outStrLen,
                                                                         void* (*mallocFunc) (size_t size), void (*freeFunc) (void *pointer),
                                                                         unsigned short flags));
_TX_DLLIMPORT_CRT ("MSVCRT",   unexpected_handler, set_unexpected,      (unexpected_handler handler));

_TX_DLLIMPORT_OPT ("OpenGL32", HDC,         wglGetCurrentDC,            (void));
_TX_DLLIMPORT_OPT ("OpenGL32", unsigned,    glGetError,                 (void));
_TX_DLLIMPORT_OPT ("Glu32",    const char*, gluErrorString,             (unsigned error));

_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     MiniDumpWriteDump,             (HANDLE process, DWORD processId, HANDLE file, MINIDUMP_TYPE dumpType,
                                                                         MINIDUMP_EXCEPTION_INFORMATION*   exceptionParam,
                                                                         MINIDUMP_USER_STREAM_INFORMATION* userStreamParam,
                                                                         MINIDUMP_CALLBACK_INFORMATION*    callbackParam));

_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("DbgHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
namespace MinGW {
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("MgwHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
} // namespace MinGW

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal function prototypes, macros and constants
//  @name    Ïðîòîòèïû âíóòðåííèõ ôóíêöèé, ìàêðîñû è êîíñòàíòû
//=================================================================================================================
//! @{

const int        _TX_IDM_ABOUT                            =   40000,       // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
                 _TX_IDM_CONSOLE                          =   40001,
                 _TX_WM_CREATEWND                         =   0x7FF0,      // Ñîîáùåíèÿ äëÿ ñîçäàíèÿ/óíè÷òîæåíèÿ
                 _TX_WM_DESTROYWND                        =   0x7FF1;      // îêîí â ïîòîêå Canvas

//-----------------------------------------------------------------------------------------------------------------

int              _txInitialize();
void             _txCleanup();

HWND             _txCanvas_CreateWindow      (const SIZE* size);
inline bool      _txCanvas_OK() tx_nodiscard;

bool             _txCanvas_OnCREATE          (HWND wnd);
bool             _txCanvas_OnDESTROY         (HWND wnd);
bool             _txCanvas_OnCLOSE           (HWND);
bool             _txCanvas_OnPAINT           (HWND wnd);
bool             _txCanvas_OnKEYDOWN         (HWND wnd, WPARAM vk, LPARAM info);
bool             _txCanvas_OnCHAR            (HWND wnd, WPARAM ch, LPARAM info);
bool             _txCanvas_OnTIMER           (HWND wnd, WPARAM id);
bool             _txCanvas_OnMOUSEMOVE       (HWND wnd, WPARAM buttons, LPARAM coords);
bool             _txCanvas_OnMOUSELEAVE      (HWND wnd);
bool             _txCanvas_OnCREATEWND       (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnDESTROYWND      (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnCmdCONSOLE      (HWND wnd, WPARAM cmd);
bool             _txCanvas_OnCmdABOUT        (HWND wnd, WPARAM cmd);

unsigned WINAPI  _txCanvas_ThreadProc        (void* data);
LRESULT CALLBACK _txCanvas_WndProc           (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);

int              _txCanvas_SetRefreshLock    (int count);

HDC              _txBuffer_Create            (HWND wnd = NULL, const POINT* size = NULL, HBITMAP bitmap = NULL,
                                              RGBQUAD** pixels = NULL) tx_nodiscard;
bool             _txBuffer_Delete            (HDC* dc);
bool             _txBuffer_Select            (HGDIOBJ obj, HDC dc = txDC());

HWND             _txConsole_Attach();
bool             _txConsole_OK() tx_nodiscard;
bool             _txConsole_Detach           (bool activate);
bool             _txConsole_Draw             (HDC dc);
bool             _txConsole_SetUnicodeFont();

const char*       txRegisterClass            (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra);
HWND              txCreateExtraWindow        (CREATESTRUCT createData);
HICON            _txCreateTXIcon             (int size) tx_nodiscard;
int              _txSetFinishedText          (HWND wnd);
void             _txPauseBeforeTermination   (HWND canvas);
int              _txIsParentWaitable         (DWORD* parentPID = NULL) tx_nodiscard;
int              _txGetInput();

LRESULT CALLBACK _txPlayVideo_WndProc        (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
const char*      _txPlayVideo_FindVLC() tx_nodiscard;

bool             _txCreateShortcut           (const char shortcutName[],
                                              const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
                                              const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
                                              const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
                                              COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));

void*            _tx_DLGTEMPLATE_Create      (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                                              WORD controls, short x, short y, short cx, short cy,
                                              const char caption[], const char font[], WORD fontsize,
                                              const char menu[]) tx_nodiscard;

void*            _tx_DLGTEMPLATE_Add         (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                                              short x, short y, short cx, short cy,
                                              WORD id, const char wclass[], const char caption[]);

const char*      _txError                    (const char file[] = NULL, int line = 0, const char func[] = NULL, unsigned color = 0,
                                              const char msg[] = NULL, ...) tx_printfy (5);
const char*      _txProcessError             (const char file[], int line, const char func[], unsigned color,
                                              const char msg[], va_list args);
void             _txOnTerminate();
void             _txOnUnexpected();
void             _txOnPureCall();
void             _txOnNewHandlerAnsi();
int              _txOnNewHandler             (size_t size);
void             _txOnSignal                 (int signal = 0, int fpe = 0);
BOOL WINAPI      _txOnConsoleCtrlEvent       (DWORD type);
void             _txOnSecurityError          (int code, void*);
void             _txOnSecurityErrorAnsi      (const char* msg, void* ptr, int code);
int              _txOnMatherr                (_exception* except);
void             _txOnInvalidParam           (const wchar_t* expr, const wchar_t* func, const wchar_t* file,
                                              unsigned line, uintptr_t);
int              _txOnAllocHook              (int type, void* data, size_t size, int use, long request,
                                              const unsigned char* file, int line);
int              _txOnRTCFailure             (int type, const char* file, int line, const char* module, const char* format, ...) tx_printfy (5);
int              _txOnErrorReport            (int type, const char* text, int* ret);
int               tx_glGetError              (int setError = INT_MIN);

void             _txOnCExit();
void             _txOnExit                   (int      retcode);
void             _txOnFatalExit              (int      retcode);
void             _txOnExitProcess            (unsigned retcode);
void             _txOnFatalAppExitA          (unsigned action, const char message[]);
bool             _txOnTerminateProcess       (HANDLE process, unsigned retcode);
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
                 _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter);
void             _txWatchdogTerminator       (void* timeout);  // Only Arnold-type series are supported, not T1000

long WINAPI      _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc);
long WINAPI      _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc);
long             _txOnExceptionSEH           (EXCEPTION_POINTERS* exc, const char func[]);
intptr_t         _txDumpExceptionSEH         (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[]);
intptr_t         _txDumpExceptionObj         (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type);
intptr_t         _txDumpExceptionCPP         (char what[], intptr_t size, unsigned code = 0,
                                              unsigned params = 0, const ULONG_PTR info[] = NULL);

void             _txStackBackTrace           (const char file[] = "?", int line = 0, const char func[] = "?",
                                              bool readSource = true);
const char*      _txCaptureStackBackTrace    (int framesToSkip = 0, bool readSource = true,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
int              _txStackWalk                (int framesToSkip, size_t szCapture, void* capture[], unsigned long* backTraceHash,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
const char*      _txCaptureStackBackTraceTX  (int framesToSkip = 0, bool readSource = false);

const char*      _txSymPrintFromAddr         (void* addr = NULL, const char format[] = NULL, ...) tx_printfy (2);
bool             _txSymGetFromAddr           (void* addr, Win32::SYMBOL_INFO** symbol = NULL,
                                              Win32::IMAGEHLP_LINE64** line = NULL, const char** module = NULL,
                                              const char** source = NULL, int context = 2);
intptr_t         _txReadSource               (char buf[], intptr_t size, const char file[],
                                              int linStart = 0, int linEnd = INT_MIN, int linMark = INT_MIN);
bool             _txCreateMiniDump           (EXCEPTION_POINTERS* exc);

uintptr_t        _txSetProcAddress           (const char funcName[], uintptr_t newFunc, const char dllName[] = NULL,
                                              int useHotPatching = false, HMODULE module = NULL, bool debug = false);
bool             _txInDll() tx_nodiscard;
PROCESSENTRY32*  _txFindProcess              (unsigned pid = GetCurrentProcessId()) tx_nodiscard;
bool             _txKillProcess              (DWORD pid);
bool             _txIsBadReadPtr             (const void* address);
bool             _txCheckSourceCP            (int needCP = _TX_CODEPAGE, bool verbose = true);
bool             _txGetCommandLine           (wchar_t cmdLine[], size_t szCmdLine, unsigned pid = _getpid());
IMAGE_NT_HEADERS*_txGetNtHeaders             (HMODULE module = GetModuleHandle (NULL)) tx_nodiscard;
const char*      _txAppInfo() tx_nodiscard;

intptr_t         _tx_snprintf_s              (char stream[], intptr_t size, const char format[], ...) tx_printfy (3);
intptr_t         _tx_vsnprintf_s             (char stream[], intptr_t size, const char format[], va_list arg);
void              txReopenStdio();

#if defined (_CLANG_VER) && !defined (_MSC_VER)
void             _txLibCppDebugFunction      (std::__libcpp_debug_info const& info);
#endif

#if defined (__CYGWIN__)

int              _getch();
int              _putch (int ch);
int              _kbhit() tx_nodiscard;

#endif

//-----------------------------------------------------------------------------------------------------------------
// There are macros for __FILE__ and __LINE__ to work properly.

#if !defined (NDEBUG)

    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) && \
                                                     (assert (cond), true) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå."), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("Ïàðàìåòð \"%s\" íåâåðåí. Âîçìîæíî, ýòîò õîëñò íå ñîçäàí, " \
                                                                "èëè óæå óíè÷òîæåí, èëè íå çàãðóçèëàñü êàðòèíêà.", #dc), 1) )
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( (!(dc) &&                                           \
                                                     _TX_TXWINDOW_FAILED()) || _TX_HDC_FAILED (dc) )

#else
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define _TX_DEFAULT_HDC_FAILED(dc)         ( !(dc) &&                                            \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
#endif

//-----------------------------------------------------------------------------------------------------------------
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but MSVC rejects it. So sad. :'(

#if !defined (NDEBUG)
    #define  _TX_ON_DEBUG( code )              { code; }
#else
    #define  _TX_ON_DEBUG( code )              ;
#endif

//-----------------------------------------------------------------------------------------------------------------
// Invokes an error without location information. "$$" restores TX-related call location context

#define _TX_UNEXPECTED( ... )                  $$ _txError (NULL, 0, NULL, 0, ##__VA_ARGS__)

//-----------------------------------------------------------------------------------------------------------------
// Safe call of a function via its pointer

#define _TX_CALL(  func, param )               ( (func)? ((func) param) :       0 )
#define _TX_CALLv( func, param )               ( (func)? ((func) param) : (void)0 )

//-----------------------------------------------------------------------------------------------------------------
// This is a macro because cond is an expression and is not always a function. Lack of lambdas in pre-C++0x.

#define      _txWaitFor( cond, time )          { for (DWORD _t = GetTickCount() + (time); \
                                                      !(cond) && GetTickCount() < _t;     \
                                                      Sleep (_txWindowUpdateInterval)) ;  \
                                                 if  (!(cond))                            \
                                                      _txTrace (__FILE__, __LINE__, NULL, "WARNING: Timeout: " #cond "."); }
//-----------------------------------------------------------------------------------------------------------------
// Detouring in case of SEH mechanism

#define _txSetJmp()                            ( setjmp (_txDumpExceptionObjJmp) == 0 )

#define _txClearJmp()                          { *(unsigned long long*) _txDumpExceptionObjJmp = 0; }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal global data
//! @name    Âíóòðåííèå ãëîáàëüíûå äàííûå
//
//           Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
//           Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåð, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
//           Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
//           Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé, èëè êëàññ.
//=================================================================================================================
//! @{

int                          _txInitialized              = _TX_NOINIT || _txInitialize();

volatile const unsigned      _txCanaryFirst              = 0x776F656D; // A very system value

volatile unsigned            _txMainThreadId             = 0;          // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
volatile HANDLE              _txMainThread               = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà

volatile unsigned            _txCanvas_ThreadId          = 0;          // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
volatile HANDLE              _txCanvas_Thread            = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
volatile HWND                _txCanvas_Window            = NULL;       // Äåñêðèïòîð îêíà õîëñòà TXLib

HDC                          _txCanvas_BackBuf[2]        = {NULL,      // [0] Main TXLib in-memory DC, where user's pictures lies
                                                            NULL};     // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()

RGBQUAD*                     _txCanvas_Pixels            = NULL;       // Memory buffer of _txCanvas_BackBuf[0]

HBITMAP                      _txStockBitmap              = NULL;       // Equivalent of GetStockObject (BITMAP),
                                                                       // see https://devblogs.microsoft.com/oldnewthing/20100416-00/?p=14313

CRITICAL_SECTION             _txCanvas_LockBackBuf       = {0,-1};     // Prevent simultaneous access to back buffer, see txLock()

UINT_PTR                     _txCanvas_RefreshTimer      = 1;          // Timer ID to redraw TXLib window
volatile int                 _txCanvas_RefreshLock       = 0;          // Blocks auto on-timer canvas update, see txBegin/txEnd

::std::vector<HDC>*          _txCanvas_UserDCs           = NULL;       // List of DCs allocated, for auto-free

volatile bool                _txConsole_IsBlinking       = true;       // To blink or not to blink, that is the question.

bool                         _txConsole                  = false;      // Only first TXLib module in app can own the console
bool                         _txMain                     = false;      // First TXLib wnd opened (closing it terminates program)
bool                         _txIsDll                    = false;      // TXLib module is in DLL
volatile bool                _txRunning                  = false;      // main() is still running
volatile bool                _txExit                     = false;      // exit() is active

volatile POINT               _txMousePos                 = {-1,-1};    // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
volatile unsigned            _txMouseButtons             = 0;

volatile WNDPROC             _txAltWndProc               = NULL;       // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().

_tx_thread _txLoc            _txLoc::Cur                 = {};         // Execution point tracking and trace state, see "$" macro

volatile int                 _txErrors                   = 0;          // TX_ERROR calls sequental number
int                          _txOGLError                 = 0;          // Last OpenGL error when using tx_glGetError()
volatile long                _txSENumber                 = 0;          // SEH exceptions sequental number
volatile long                _txSEFatalNumber            = 0;          // SEH fatal exceptions sequental number
char                         _txDumpSE [_TX_BUFSIZE]     = "";         // SEH dump data area
char                         _txTraceSE[_TX_HUGEBUFSIZE] = "";         // Stack trace data area

LPTOP_LEVEL_EXCEPTION_FILTER _txPrevUEFilter             = NULL;       // Previous UnhandledExceptionFilter

jmp_buf                      _txDumpExceptionObjJmp      = {};         // Hook for _txDumpExceptionObj

const volatile uintptr_t     _txForceImport[]            = { (uintptr_t) ::TerminateProcess,              (uintptr_t) ::ExitProcess,
                                                             (uintptr_t) ::FatalExit,                     (uintptr_t) ::FatalAppExitA,
                                                             (uintptr_t) ::exit,                          (uintptr_t) Win32::_controlfp,
                                                             (uintptr_t) Win32::Polyline,                 (uintptr_t) Win32::PolyBezier,
                                                             (uintptr_t) Win32::RoundRect,                (uintptr_t) Win32::RemoveVectoredExceptionHandler,
                                                             (uintptr_t) Win32::PlgBlt,                   (uintptr_t) Win32::RtlCaptureStackBackTrace,
                                                             (uintptr_t) Win32::SymInitialize,            (uintptr_t) Win32::MinGW::SymInitialize,
                                                             (uintptr_t) Win32::SymSetOptions,            (uintptr_t) Win32::MinGW::SymSetOptions,
                                                             (uintptr_t) Win32::SymGetLineFromAddr64,     (uintptr_t) Win32::MinGW::SymGetLineFromAddr64,
                                                             (uintptr_t) Win32::SymFromAddr,              (uintptr_t) Win32::MinGW::SymFromAddr,
                                                             (uintptr_t) Win32::SymCleanup,               (uintptr_t) Win32::MinGW::SymCleanup,
                                                             (uintptr_t) Win32::SymGetModuleBase64,       (uintptr_t) Win32::MinGW::SymGetModuleBase64,
                                                             (uintptr_t) Win32::SymFunctionTableAccess64, (uintptr_t) Win32::MinGW::SymFunctionTableAccess64,
                                                             (uintptr_t) Win32::StackWalk64,              (uintptr_t) Win32::MinGW::StackWalk64,
                                                             (uintptr_t) Win32::StrStrIA,                 (uintptr_t) Win32::Wow64GetThreadContext };

volatile const unsigned      _txCanaryLast               = 0x5E2E2E5E; // Another very system value

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib engine init/check/cleanup
//! @name    Èíèöèàëèçàöèÿ/ïðîâåðêà/çàâåðøåíèå TXLib
//=================================================================================================================
//! @{

//-----------------------------------------------------------------------------------------------------------------
//{          Early initialization
//-----------------------------------------------------------------------------------------------------------------

int _txInitialize()
    {
    if (_txInitialized) return 1;
    _txInitialized = 1;

    #if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)  // See http://msdn.microsoft.com/en-us/library/w2fhc9a3%28v=vs.90%29.aspx
    _CrtSetBreakAlloc (_TX_ALLOC_BREAK);                 // and http://support.microsoft.com/ru-ru/kb/151585
    #endif

    #if defined (_TX_ALLOW_TRACE)
    _txLocLvlSet (1);
    #endif

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
                                     "compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

    _txMainThreadId = GetCurrentThreadId();
    _txMainThread   = OpenThread (THREAD_ALL_ACCESS, false, _txMainThreadId);

$3  _txIsDll = _txInDll();

$   if (!_txIsDll)
        {
$       _txConsole = ! FindAtom ("_txConsole");
$       (void)          AddAtom ("_txConsole");
        }

$   if (_txConsole)
        {
$       _txCheckSourceCP (_TX_CODEPAGE, true);

$       unsigned long stackSize = _TX_STACKSIZE;
$       _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$       _txOnSignal();

$       if (!*_txLogName)
            {$ _tx_snprintf_s (_txLogName, sizeof (_txLogName) - 1, "%s.log", txGetModuleFileName()); }

$       if (!_txIsDll)
            {
$           _TX_CALL  (Win32::AddVectoredExceptionHandler, (1, (PVECTORED_EXCEPTION_HANDLER)  _txVectoredExceptionHandler));
$           _txPrevUEFilter = SetUnhandledExceptionFilter  (   (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter);
            }

$       ::std::set_terminate             (_txOnTerminate);
$       ::std::set_new_handler           (_txOnNewHandlerAnsi);
$       _TX_CALL (Win32::set_unexpected, (_txOnUnexpected));

        #if defined (_CLANG_VER) && !defined (_MSC_VER)
$       ::std::__libcpp_debug_function = _txLibCppDebugFunction;
        #endif

$       SetConsoleCtrlHandler (_txOnConsoleCtrlEvent, true);

$       SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);

        #if defined (_MSC_VER)

$       _set_printf_count_output (1);

$       _set_new_handler (_txOnNewHandler);
$       _set_new_mode (1);

        #if !defined (_CLANG_VER)

$       _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$       _CrtSetAllocHook (_txOnAllocHook);

$       unsigned mode = _CRTDBG_MODE_FILE;
$       if (_CrtSetReportHook2 (_CRT_RPTHOOK_INSTALL, (_CRT_REPORT_HOOK) _txOnErrorReport) > 0) mode = 0;

$       _CrtSetReportMode (_CRT_WARN,   _CRTDBG_MODE_DEBUG | mode);
$       _CrtSetReportMode (_CRT_ERROR,  _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportFile (_CRT_WARN,   _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ERROR,  _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);

        #endif

$       _set_abort_behavior (_WRITE_ABORT_MSG, _WRITE_ABORT_MSG);
$       _set_abort_behavior (0,                _CALL_REPORTFAULT);

$       _RTC_SetErrorFunc              (_txOnRTCFailure);
$       _set_purecall_handler          (_txOnPureCall);
$       _set_invalid_parameter_handler (_txOnInvalidParam);

        #endif

        #if defined (__STDC_LIB_EXT1__)
$       ::std::set_constraint_handler_s (_txOnSecurityErrorAnsi);
        #endif

        #if !defined (__CYGWIN__) && defined (_GCC_VER) && (_GCC_VER >= 530) && !defined (i386)
$       __setusermatherr (_txOnMatherr);
        #endif

        #if !defined (__CYGWIN__)
$       _set_error_mode (_OUT_TO_MSGBOX | _OUT_TO_STDERR);
        #endif

$       HWND console = _txConsole_Attach();
$       SetWindowTextA (console, txGetModuleFileName (false));
        }

$   InitializeCriticalSection (&_txCanvas_LockBackBuf);

$   _txSetProcAddress ("ExitProcess",                 (uintptr_t) _txOnExitProcess,                 "KERNEL32.DLL");
$   _txSetProcAddress ("TerminateProcess",            (uintptr_t) _txOnTerminateProcess,            "KERNEL32.DLL");
$   _txSetProcAddress ("FatalExit",                   (uintptr_t) _txOnFatalExit,                   "KERNEL32.DLL");
$   _txSetProcAddress ("FatalAppExitA",               (uintptr_t) _txOnFatalAppExitA,               "KERNEL32.DLL");
$   _txSetProcAddress ("UnhandledExceptionFilter",    (uintptr_t) _txUnhandledExceptionFilter,      "KERNEL32.DLL", true);
$   _txSetProcAddress ("SetUnhandledExceptionFilter", (uintptr_t) _txOnSetUnhandledExceptionFilter, "KERNEL32.DLL");
$   _txSetProcAddress ("exit",                        (uintptr_t) _txOnExit);
$   _txSetProcAddress ("_cexit",                      (uintptr_t) _txOnCExit);

$   atexit (_txCleanup);

$   if (_txConsole)
        {
$       txSetConsoleAttr (FOREGROUND_LIGHTGRAY);

$       tx_fpreset();

$       srand ((unsigned) time (NULL));

$       SetLastError (0);
$       errno = 0;

        #if !defined (__CYGWIN__)
$       _doserrno = 0;
        #endif
        }

$   HDC dc = Win32::CreateCompatibleDC (NULL); dc asserted;
$   _txStockBitmap = (HBITMAP) Win32::SelectObject (dc, Win32::CreateCompatibleBitmap (dc, 1, 1)); _txStockBitmap asserted;
$   Win32::DeleteObject (Win32::SelectObject (dc, _txStockBitmap)) asserted;
$   Win32::DeleteDC (dc) asserted;

$   return 1;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCheckSourceCP (int needCP /*= _TX_CODEPAGE*/, bool verbose /*= true*/)
    {
$3  const char* sCodePage = NULL;
$   int codePage = 0;

$   switch (((unsigned const char*) "À") [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }

$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please

$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }

$   return (codePage == needCP);
    }

//-----------------------------------------------------------------------------------------------------------------

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;

    static char dllPaths [2][MAX_PATH] = {"", ""};

    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";

        // dllPaths[0] is relative to the TX Setup directory stored in the Registry

        char* path = dllPaths[0];

        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);

        // dllPaths[1] is relative to TXib.h file used in compilation

        path = dllPaths[1];

        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }

        if (char* dir = strrchr (path, '\\')) *dir = 0;

        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }

    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);

    if (arch)
        {
        assert (arch >= dllFileName);

        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));

        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }

    HMODULE   dll = GetModuleHandle (dllFileName);

    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);

    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);

        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);

        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }

    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);

    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;

    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);

    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè
#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
    //     äèàëîãà          | ýëåìåíòà | ôèêàòîð   |-----------------| (ñì. îïèñàíèå ýëåìåíòîâ    //                      |          | ýëåìåíòà  | X | Y |Øèð.|Âûñ.| îêîí äèàëîãà â MSDN)
    //----------------------+----------+-----------+---+---+----+----+---------------------------------------------
    //                      |          |           |   |   |    |    |
        {{ txDialog::DIALOG,  caption,   0,           0,  0, 240,  85                                                    },
         { txDialog::STATIC,  text,      ID_TEXT_,   10, 10, 150,  40, SS_LEFT                                           },
         { txDialog::EDIT,    input,     ID_INPUT_,  10, 60, 220,  15, ES_LEFT | WS_BORDER | ES_AUTOHSCROLL | WS_TABSTOP },
         { txDialog::BUTTON,  "&OK",     IDOK,      180, 10,  50,  15, BS_DEFPUSHBUTTON                     | WS_TABSTOP },
         { txDialog::BUTTON,  "&Cancel", IDCANCEL,  180, 30,  50,  15, BS_PUSHBUTTON                        | WS_TABSTOP },
         { txDialog::END                                                                                                 }};

    //-------------------------------------------------------------------------------------------------------------
    // Êëàññ äèàëîãà äëÿ InputBox. Âíóòðåííèé, ò.ê. çà÷åì åìó áûòü âíåøíèì.
    // Íóæåí â îñíîâíîì äëÿ çàäàíèÿ ñòðîêè ââîäà (str) è îêîííîé ôóíêöèè äèàëîãîâîãî îêíà, òðåáóåìîé Win32 (îíà
    // ïîñòðîåíà ìàêðîñàìè TX_BEGIN_MESSAGE_MAP è äðóãèìè). Ìîæíî íå äåëàòü âíóòðåííåãî êëàññà, íî òîãäà îêîííóþ
    // ôóíêöèþ ïðèäåòñÿ ïèñàòü â ãëîáàëüíîé îáëàñòè âèäèìîñòè, è str îáúÿâëÿòü ãëîáàëüíî òîæå (èëè ïåðåäàâàòü åå
    // àäðåñ ÷åðåç DialogBoxParam è çàïèñûâàòü åãî â êëàññ âî âðåìÿ îáðàáîòêè WM_INITDIALOG).
    //-------------------------------------------------------------------------------------------------------------
    struct inputDlg : txDialog
        {
        char str [1024];

        //---------------------------------------------------------------------------------------------------------

        inputDlg() :
            str()
            {}

        //---------------------------------------------------------------------------------------------------------

        TX_BEGIN_MESSAGE_MAP()    // Êàðòà ñîîáùåíèé (íà ñàìîì äåëå ýòî íà÷àëî îêîííîé ôóíêöèè).

            TX_COMMAND_MAP        // Çäåñü îáðàáàòûâàþòñÿ WM_COMMAND (íà ñàìîì äåëå ýòî îïåðàòîð switch).

                //-------------------------------------------------------------------------------------------------
                // Ïðè íàæàòèè êíîïêè OK êîïèðóåì ñòðîêó èç ïîëÿ ââîäà â íàøó ïåðåìåííóþ str, ò.ê. ïîñëå çàêðûòèÿ
                // äèàëîãà ñòðîêà ââîäà óìðåò è òåêñò óæå èç íåå ïîëó÷èòü.
                // Ýòîò ìàêðîñ íà ñàìîì äåëå ïðåâðàùàåòñÿ â case èç îïåðàòîðà switch.
                // _wnd -- ýòî ïàðàìåòð îêîííîé ôóíêöèè, ñì. îïðåäåëåíèå ìàêðîñà TX_BEGIN_MESSAGE_MAP().
                //-------------------------------------------------------------------------------------------------

                TX_HANDLE (IDOK) GetDlgItemText (_wnd, ID_INPUT_, str, sizeof (str) - 1);

        TX_END_MESSAGE_MAP

        //---------------------------------------------------------------------------------------------------------
        // Êîíåö âíóòðåííåãî êëàññà äèàëîãà
        //---------------------------------------------------------------------------------------------------------
        };

    //-------------------------------------------------------------------------------------------------------------
    // Óáèðàåì äåôàéíû, ÷òîáû ïîòîì íå ìåøàëè.
    // Îò ýòîãî îíè ïîëó÷àþòñÿ "ëîêàëüíîãî äåéñòâèÿ", êàê áóäòî ó íèõ áûëà áû îáëàñòü âèäèìîñòè -- ôóíêöèÿ. Íà ñàìîì
    // äåëå ýòî ñäåëàíî âðó÷íóþ ÷åðåç #undef. ×òîáû ïîä÷åðêíóòü èõ ëîêàëüíóþ ïðèðîäó, ó íèõ èìåíà çàêàí÷èâàþòñÿ íà _.
    // Òàêèå äåôàéíû ïîòîì íå ïåðåêîñÿ÷àò âåñü êîä ïîñëå òîãî êàê, ôàêòè÷åñêè, ñòàëè óæå íå íóæíû.
    //-------------------------------------------------------------------------------------------------------------

    #undef ID_TEXT_
    #undef ID_INPUT_

    //-------------------------------------------------------------------------------------------------------------
    // Ýòî ñòàòè÷åñêèé îáúåêò, ïîòîìó ÷òî ñòðîêà â íåì äîëæíà æèòü ïîñëå çàâåðøåíèÿ ôóíêöèè.
    //-------------------------------------------------------------------------------------------------------------

    static inputDlg dlg;

    //-------------------------------------------------------------------------------------------------------------
    // Ïåðåäàåì layout è çàïóñêàåì îêíî äèàëîãà
    //-------------------------------------------------------------------------------------------------------------

    dlg.dialogBox (layout);

    //-------------------------------------------------------------------------------------------------------------
    // Âîçâðàùàåì àäðåñ ñòðîêè èç ñòàòè÷åñêîãî îáúåêòà. Òàê ìîæíî äåëàòü, ïîòîìó ÷òî ñòàòè÷åñêèé îáúåêò íå óìðåò
    // ïðè âûõîäå èç ôóíêöèè è ñòðîêà â íåì, ñîîòâåòñòâåííî, òîæå. Àäðåñ íåñòàòè÷åñêèõ ïåðåìåííûõ ïåðåäàâàòü
    // ñèíòàêñè÷åñêè ìîæíî, íî âåäåò ê ñåðüåçíûì îøèáêàì.
    //-------------------------------------------------------------------------------------------------------------

    return dlg.str;
    }

//! @}
//}
//=================================================================================================================

//}
//=================================================================================================================

//=================================================================================================================
//{          TXLIB IMPLEMENTATION
//           Ðåàëèçàöèÿ ôóíêöèé áèáëèîòåêè
//=================================================================================================================
//! @cond INTERNAL

//=================================================================================================================
//{          DLL functions import, missing types definitions
//! @name    Èìïîðò âíåøíèõ áèáëèîòåê, îïðåäåëåíèå íåäîñòàþùèõ òèïîâ
//=================================================================================================================
//! @{

namespace Win32 {

//-----------------------------------------------------------------------------------------------------------------
//{ Some of structs, consts and interfaces aren't defined in MinGW some early headers.
//  Copied from Windows SDK 7.0a.
//-----------------------------------------------------------------------------------------------------------------

#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                             0x01
#endif

#ifndef SMTO_ERRORONEXIT
#define SMTO_ERRORONEXIT                         0x0020
#endif

#ifndef NT_CONSOLE_PROPS_SIG
#define NT_CONSOLE_PROPS_SIG                     0xA0000002
#endif

#ifndef NIIF_INFO
#define NIIF_INFO                                0x00000001
#define NIIF_WARNING                             0x00000002
#define NIIF_ERROR                               0x00000003
#endif

#ifndef NIF_INFO
#define NIF_STATE                                0x00000008
#define NIF_INFO                                 0x00000010
#endif

#ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
#define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS   0x00000004
#endif

#ifndef SYMOPT_CASE_INSENSITIVE
#define SYMOPT_CASE_INSENSITIVE                  0x00000001
#define SYMOPT_UNDNAME                           0x00000002
#define SYMOPT_DEFERRED_LOADS                    0x00000004
#define SYMOPT_NO_CPP                            0x00000008
#define SYMOPT_LOAD_LINES                        0x00000010
#define SYMOPT_OMAP_FIND_NEAREST                 0x00000020
#define SYMOPT_LOAD_ANYTHING                     0x00000040
#define SYMOPT_IGNORE_CVREC                      0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS              0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS              0x00000200
#define SYMOPT_EXACT_SYMBOLS                     0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS            0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH                 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES             0x00002000
#define SYMOPT_PUBLICS_ONLY                      0x00004000
#define SYMOPT_NO_PUBLICS                        0x00008000
#define SYMOPT_AUTO_PUBLICS                      0x00010000
#define SYMOPT_NO_IMAGE_SEARCH                   0x00020000
#define SYMOPT_SECURE                            0x00040000
#define SYMOPT_NO_PROMPTS                        0x00080000
#define SYMOPT_ALLOW_ZERO_ADDRESS                0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT         0x02000000
#define SYMOPT_FAVOR_COMPRESSED                  0x00800000
#define SYMOPT_FLAT_DIRECTORY                    0x00400000
#define SYMOPT_IGNORE_IMAGEDIR                   0x00200000
#define SYMOPT_OVERWRITE                         0x00100000
#define SYMOPT_DEBUG                             0x80000000
#endif

// SEH exception codes. For GCC, see http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 64-66.

#ifndef STATUS_POSSIBLE_DEADLOCK
#define STATUS_POSSIBLE_DEADLOCK                 0xC0000194
#endif

#ifndef STATUS_FLOAT_MULTIPLE_FAULTS
#define STATUS_FLOAT_MULTIPLE_FAULTS             0xC00002B4
#endif

#ifndef STATUS_STACK_BUFFER_OVERRUN
#define STATUS_STACK_BUFFER_OVERRUN              0xC0000409
#endif

#ifndef STATUS_ASSERTION_FAILURE
#define STATUS_ASSERTION_FAILURE                 0xC0000420
#endif

#ifndef STATUS_WX86_BREAKPOINT
#define STATUS_WX86_BREAKPOINT                   0x4000001F
#endif

#ifndef DBG_PRINTEXCEPTION_C
#define DBG_PRINTEXCEPTION_C                     0x40010006  // OutputDebugStringA() call
#endif

#ifndef DBG_PRINTEXCEPTION_WIDE_C
#define DBG_PRINTEXCEPTION_WIDE_C                0x4001000A  // OutputDebugStringW() call
#endif

#ifndef DBG_THREAD_NAME
#define DBG_THREAD_NAME                          0x406D1388
#endif

#define EXCEPTION_CPP_MSC                        0xE06D7363  // '?msc'
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1       0x19930520  // '?msc' version magic, see ehdata.h
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2       0x19930521  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3       0x19930522  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1  0x01994000  // '?msc' version magic

#define EXCEPTION_CPP_GCC                        0x20474343  // ' GCC'
#define EXCEPTION_CPP_GCC_UNWIND                 0x21474343  // '!GCC'
#define EXCEPTION_CPP_GCC_FORCED                 0x22474343  // '"GCC'

#define EXCEPTION_CLR_FAILURE                    0xE0434f4D  // 'àCOM'

#define EXCEPTION_CPP_BORLAND_BUILDER            0x0EEDFAE6  // Should never occur here
#define EXCEPTION_CPP_BORLAND_DELPHI             0x0EEDFADE  // Should never occur here

#pragma pack (push, 1)

struct CONSOLE_CURSOR_INFO
    {
    DWORD dwSize;
    BOOL bVisible;
    };

struct CONSOLE_FONT_INFO
    {
    DWORD nFont;
    COORD dwFontSize;
    };

struct CONSOLE_FONT_INFOEX
    {
    ULONG cbSize;
    DWORD nFont;
    COORD dwFontSize;
    UINT  FontFamily;
    UINT  FontWeight;
    WCHAR FaceName[LF_FACESIZE];
    };

struct DATABLOCK_HEADER
    {
    DWORD cbSize;
    DWORD dwSignature;
    };

struct NT_CONSOLE_PROPS
    {
    DATABLOCK_HEADER dbh;

    WORD  wFillAttribute;
    WORD  wPopupFillAttribute;
    COORD dwScreenBufferSize;
    COORD dwWindowSize;
    COORD dwWindowOrigin;
    DWORD nFont;
    DWORD nInputBufferSize;
    COORD dwFontSize;
    UINT  uFontFamily;
    UINT  uFontWeight;
    WCHAR FaceName[LF_FACESIZE];
    UINT  uCursorSize;
    BOOL  bFullScreen;
    BOOL  bQuickEdit;
    BOOL  bInsertMode;
    BOOL  bAutoPosition;
    UINT  uHistoryBufferSize;
    UINT  uNumberOfHistoryBuffers;
    BOOL  bHistoryNoDup;

    COLORREF ColorTable[16];
    };

#pragma pack (pop)

#undef  INTERFACE
#define INTERFACE IShellLinkDataList

DECLARE_INTERFACE_ (IShellLinkDataList, IUnknown)
    {
    // *** IUnknown methods ***
    STDMETHOD (QueryInterface)  (THIS_ REFIID iid, void** value)    _tx_override PURE;
    STDMETHOD_(ULONG, AddRef)   (THIS)                              _tx_override PURE;
    STDMETHOD_(ULONG, Release)  (THIS)                              _tx_override PURE;

    // *** IShellLinkDataList methods ***
    STDMETHOD (AddDataBlock)    (THIS_ void* dataBlock)             PURE;
    STDMETHOD (CopyDataBlock)   (THIS_ DWORD sig, void** dataBlock) PURE;
    STDMETHOD (RemoveDataBlock) (THIS_ DWORD sig)                   PURE;
    STDMETHOD (GetFlags)        (THIS_ DWORD* flags)                PURE;
    STDMETHOD (SetFlags)        (THIS_ DWORD  flags)                PURE;

    protected:
    virtual ~IShellLinkDataList();
    };

const GUID IID_IShellLink         = {0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID IID_IShellLinkDataList = {0x45e2b4ae, 0xb1c3, 0x11d0, {0xb9,0x2f,0x00,0xa0,0xc9,0x03,0x12,0xe1}};
const GUID IID_IPersistFile       = {0x0000010b, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};

const GUID CLSID_SpVoice          = {0x96749377, 0x3391, 0x11d2, {0x9e,0xe3,0x00,0xc0,0x4f,0x79,0x73,0x96}};
const GUID IID_ISpVoice           = {0x6c44df74, 0x72b9, 0x4992, {0xa1,0xec,0xef,0x99,0x6e,0x04,0x22,0xd4}};

#undef  INTERFACE

typedef DWORD     NTSTATUS;
typedef ULONG_PTR KAFFINITY;
typedef LONG      KPRIORITY;

struct UNICODE_STRING
    {
    USHORT Length;
    USHORT MaximumLength;
    WCHAR* Buffer;
    };

struct RTL_USER_PROCESS_PARAMETERS
    {
    BYTE  Reserved1[16];
    void* Reserved2[10];
    UNICODE_STRING ImagePathName;
    UNICODE_STRING CommandLine;
    };

struct PEB
    {
    BYTE  Reserved1[2];
    BYTE  BeingDebugged;
    BYTE  Reserved2[1];
    void* Reserved3[2];
    void* Ldr;
    RTL_USER_PROCESS_PARAMETERS* ProcessParameters;
    void* Reserved4[3];
    void* AtlThunkSListPtr;
    void* Reserved5;
    ULONG Reserved6;
    void* Reserved7;
    ULONG Reserved8;
    ULONG AtlThunkSListPtr32;
    void* Reserved9[45];
    BYTE  Reserved10[96];
    void* PostProcessInitRoutine;
    BYTE  Reserved11[128];
    void* Reserved12[1];
    ULONG SessionId;
    };

struct PROCESS_BASIC_INFORMATION
    {
    NTSTATUS  ExitStatus;
    PEB*      PebBaseAddress;
    KAFFINITY AffinityMask;
    KPRIORITY BasePriority;
    ULONG_PTR UniqueProcessId;
    ULONG_PTR InheritedFromUniqueProcessId;
    };

enum ADDRESS_MODE
    {
    AddrMode1616,
    AddrMode1632,
    AddrModeReal,
    AddrModeFlat
    };

struct ADDRESS64
    {
    DWORD64      Offset;
    WORD         Segment;
    ADDRESS_MODE Mode;
    };

struct KDHELP64
    {
    DWORD64 Thread;
    DWORD   ThCallbackStack;
    DWORD   ThCallbackBStore;
    DWORD   NextCallback;
    DWORD   FramePointer;
    DWORD64 KiCallUserMode;
    DWORD64 KeUserCallbackDispatcher;
    DWORD64 SystemRangeStart;
    DWORD64 KiUserExceptionDispatcher;
    DWORD64 StackBase;
    DWORD64 StackLimit;
    DWORD64 Reserved[5];
    };

struct STACKFRAME64
    {
    ADDRESS64 AddrPC;
    ADDRESS64 AddrReturn;
    ADDRESS64 AddrFrame;
    ADDRESS64 AddrStack;
    ADDRESS64 AddrBStore;
    PVOID     FuncTableEntry;
    DWORD64   Params[4];
    BOOL      Far;
    BOOL      Virtual;
    DWORD64   Reserved[3];
    KDHELP64  KdHelp;
    };

struct WOW64_FLOATING_SAVE_AREA
    {
    DWORD ControlWord;
    DWORD StatusWord;
    DWORD TagWord;
    DWORD ErrorOffset;
    DWORD ErrorSelector;
    DWORD DataOffset;
    DWORD DataSelector;
    BYTE  RegisterArea[80];
    DWORD Cr0NpxState;
    };

#pragma pack (push, 4)

struct WOW64_CONTEXT
    {
    DWORD ContextFlags;

    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;

    WOW64_FLOATING_SAVE_AREA FloatSave;

    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;

    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;

    DWORD Ebp;
    DWORD Eip;
    DWORD SegCs;
    DWORD EFlags;
    DWORD Esp;
    DWORD SegSs;

    BYTE  ExtendedRegisters[512];
    };

#pragma pack (pop)

struct SYMBOL_INFO
    {
    ULONG   SizeOfStruct;
    ULONG   TypeIndex;
    ULONG64 Reserved[2];
    ULONG   info;
    ULONG   Size;
    ULONG64 ModBase;
    ULONG   Flags;
    ULONG64 Value;
    ULONG64 Address;
    ULONG   Register;
    ULONG   Scope;
    ULONG   Tag;
    ULONG   NameLen;
    ULONG   MaxNameLen;
    CHAR    Name[1];
    };

struct IMAGEHLP_LINE64
    {
    DWORD   SizeOfStruct;
    PVOID   Key;
    DWORD   LineNumber;
    PCHAR   FileName;
    DWORD64 Address;
    };

typedef bool    (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)   (HANDLE process, DWORD64 baseAddress, void* buffer, DWORD size, DWORD* bytesRead);
typedef void*   (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64) (HANDLE process, DWORD64 baseAddress);
typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)       (HANDLE process, DWORD64 address);
typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)     (HANDLE process, HANDLE thread, ADDRESS64* address);

typedef void (*unexpected_handler)();

#pragma pack (push, 4)

struct MINIDUMP_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    };

struct MINIDUMP_THREAD_EX_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    ULONG64  BackingStoreBase;
    ULONG64  BackingStoreEnd;
    };

struct MINIDUMP_MODULE_CALLBACK
    {
    wchar_t* FullPath;
    ULONG64  BaseOfImage;
    ULONG    SizeOfImage;
    ULONG    CheckSum;
    ULONG    TimeDateStamp;
    VS_FIXEDFILEINFO VersionInfo;
    void*    CvRecord;
    ULONG    SizeOfCvRecord;
    PVOID    MiscRecord;
    ULONG    SizeOfMiscRecord;
    };

struct MINIDUMP_INCLUDE_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    };

struct MINIDUMP_INCLUDE_MODULE_CALLBACK
    {
    ULONG64  BaseOfImage;
    };

struct MINIDUMP_MEMORY_INFO
    {
    ULONG64  BaseAddress;
    ULONG64  AllocationBase;
    ULONG32  AllocationProtect;
    ULONG32  __alignment1;
    ULONG64  RegionSize;
    ULONG32  State;
    ULONG32  Protect;
    ULONG32  Type;
    ULONG32  __alignment2;
    };

struct MINIDUMP_USER_STREAM
    {
    ULONG32  Type;
    ULONG    BufferSize;
    PVOID    Buffer;
    };

struct MINIDUMP_USER_STREAM_INFORMATION
    {
    ULONG                 UserStreamCount;
    MINIDUMP_USER_STREAM* UserStreamArray;
    };

struct MINIDUMP_CALLBACK_INPUT
    {
    ULONG    ProcessId;
    HANDLE   ProcessHandle;
    ULONG    CallbackType;

    union
        {
        MINIDUMP_THREAD_CALLBACK         Thread;
        MINIDUMP_THREAD_EX_CALLBACK      ThreadEx;
        MINIDUMP_MODULE_CALLBACK         Module;
        MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
        MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
        };
    };

struct MINIDUMP_CALLBACK_OUTPUT
    {
    union
        {
        ULONG ModuleWriteFlags;
        ULONG ThreadWriteFlags;
        ULONG SecondaryFlags;

        struct
            {
            ULONG64  MemoryBase;
            ULONG    MemorySize;
            };

        struct
            {
            unsigned CheckCancel;
            unsigned Cancel;
            };

        HANDLE Handle;
        };

    struct
        {
        MINIDUMP_MEMORY_INFO VmRegion;
        unsigned             Continue;
        };

    HRESULT Status;
    };

struct MINIDUMP_EXCEPTION_INFORMATION
    {
    DWORD               ThreadId;
    EXCEPTION_POINTERS* ExceptionPointers;
    unsigned            ClientPointers;
    };

typedef int (WINAPI* MINIDUMP_CALLBACK_ROUTINE) (void* param, MINIDUMP_CALLBACK_INPUT* input, MINIDUMP_CALLBACK_OUTPUT* output);

struct MINIDUMP_CALLBACK_INFORMATION
    {
    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
    void*                     CallbackParam;
    };

enum MINIDUMP_TYPE
    {
    MiniDumpNormal                         = 0x00000000,
    MiniDumpWithDataSegs                   = 0x00000001,
    MiniDumpWithFullMemory                 = 0x00000002,
    MiniDumpWithHandleData                 = 0x00000004,
    MiniDumpFilterMemory                   = 0x00000008,
    MiniDumpScanMemory                     = 0x00000010,
    MiniDumpWithUnloadedModules            = 0x00000020,
    MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
    MiniDumpFilterModulePaths              = 0x00000080,
    MiniDumpWithProcessThreadData          = 0x00000100,
    MiniDumpWithPrivateReadWriteMemory     = 0x00000200,
    MiniDumpWithoutOptionalData            = 0x00000400,
    MiniDumpWithFullMemoryInfo             = 0x00000800,
    MiniDumpWithThreadInfo                 = 0x00001000,
    MiniDumpWithCodeSegs                   = 0x00002000,
    MiniDumpWithoutAuxiliaryState          = 0x00004000,
    MiniDumpWithFullAuxiliaryState         = 0x00008000,
    MiniDumpWithPrivateWriteCopyMemory     = 0x00010000,
    MiniDumpIgnoreInaccessibleMemory       = 0x00020000,
    MiniDumpWithTokenInformation           = 0x00040000
    };

#pragma pack (pop)

#define FOREGROUND_BLACK         ( 0                                                         )
#define FOREGROUND_CYAN          ( FOREGROUND_BLUE       | FOREGROUND_GREEN                  )
#define FOREGROUND_MAGENTA       ( FOREGROUND_BLUE       | FOREGROUND_RED                    )
#define FOREGROUND_DARKYELLOW    ( FOREGROUND_GREEN      | FOREGROUND_RED                    )
#define FOREGROUND_LIGHTGRAY     ( FOREGROUND_BLUE       | FOREGROUND_GREEN | FOREGROUND_RED )
#define FOREGROUND_DARKGRAY      (                         FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTBLUE     ( FOREGROUND_BLUE       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTGREEN    ( FOREGROUND_GREEN      | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTCYAN     ( FOREGROUND_CYAN       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTRED      ( FOREGROUND_RED        | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTMAGENTA  ( FOREGROUND_MAGENTA    | FOREGROUND_INTENSITY              )
#define FOREGROUND_YELLOW        ( FOREGROUND_DARKYELLOW | FOREGROUND_INTENSITY              )
#define FOREGROUND_WHITE         ( FOREGROUND_LIGHTGRAY  | FOREGROUND_INTENSITY              )

#define BACKGROUND_BLACK         ( 0                                                         )
#define BACKGROUND_CYAN          ( BACKGROUND_BLUE       | BACKGROUND_GREEN                  )
#define BACKGROUND_MAGENTA       ( BACKGROUND_BLUE       | BACKGROUND_RED                    )
#define BACKGROUND_DARKYELLOW    ( BACKGROUND_GREEN      | BACKGROUND_RED                    )
#define BACKGROUND_GRAY          ( BACKGROUND_BLUE       | BACKGROUND_GREEN | BACKGROUND_RED )
#define BACKGROUND_DARKGRAY      (                         BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTBLUE     ( BACKGROUND_BLUE       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTGREEN    ( BACKGROUND_GREEN      | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTCYAN     ( BACKGROUND_CYAN       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTRED      ( BACKGROUND_RED        | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTMAGENTA  ( BACKGROUND_MAGENTA    | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTYELLOW   ( BACKGROUND_DARKYELLOW | BACKGROUND_INTENSITY              )
#define BACKGROUND_WHITE         ( BACKGROUND_DARKGRAY   | BACKGROUND_INTENSITY              )

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ There are copies of MSVC compiler built-in predefined definitions, which are wrong in 64-bit mode.
//  So we have to override them. See: http://stackoverflow.com/questions/39113168
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)
                                                    //  MS ABI C++ Exception Layout
namespace Win32 {                                   //  ---------------------------
                                                    //
#pragma pack (push, 4)                              //   EXCEPTION_RECORD:
                                                    //  +==================================================+
struct ThrowInfo                                    //  |...                                               |
    {                                               //  |NumberParameters:        3, 4 or more             |
    __int32 attributes;                             //  |ExceptionInformation[0]: MS signature 0x19930520  |
    __int32 pmfnUnwind;                             //  |ExceptionInformation[1]: object* thrown           |
    __int32 pForwardCompat;                         //  |ExceptionInformation[2]: ThrowInfo* --------------+---+
    __int32 pCatchableTypeArray;                    //  |ExceptionInformation[3]: ImageBase (if params > 3)|   |
    };                                              //  +==================================================+   |
                                                    //                                                         |
struct CatchableTypeArray                           //        ThrowInfo:                                       |
    {                                               //        +======================================+ <-------+
    __int32 nCatchableTypes;                        //        |   ...                                |
    __int32 arrayOfCatchableTypes[];                //  +-----+-- pCatchableTypeArray (ptr/RVA)      |
    };                                              //  |     +======================================+
                                                    //  |
struct CatchableType                                //  |     CatchableTypeArray:
    {                                               //  +---> +======================================+
    __int32 properties;                             //        |   ...                                |
    __int32 pType;                                  //  +-----+-- arrayOfCatchableTypes[0] (ptr/RVA) |
    __int32 thisDisplacement[3]; // struct _PMD     //  |     +======================================+
    __int32 sizeOrOffset;                           //  |
    __int32 copyFunction;                           //  |     CatchableType:
    };                                              //  +---> +====================+
                                                    //        | ...                |        std::type_info:
#pragma pack (pop)                                  //        | pType (ptr/RVA) ---+------> +==================+
                                                    //        | ...                |        |type_info data    |
} // namespace Win32                                //        +====================+        |...               |
                                                    //                                      +==================+
#endif

// Similar to __CxxDetectRethrow(), see C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\crtsrc\vcruntime\frame.cpp:

#define _TX_MSC__CXX_DETECT_RETHROW( exc )                                     \
    (                                                                          \
    (exc)                                          &&                          \
    (exc) -> ExceptionCode    == EXCEPTION_CPP_MSC &&                          \
    (exc) -> NumberParameters >= 3                 &&                          \
                                                                               \
    ((exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3) && \
                                                                               \
    (exc) -> ExceptionInformation[2] == 0                                      \
    )

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ The corresponding structures for GCC
//
//  From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/unwind-cxx.h
//  See:  http://mentorembedded.github.io/cxx-abi/abi-eh.html#cxx-abi
//-----------------------------------------------------------------------------------------------------------------

#if defined (_GCC_VER)
                                                    // GCC ABI C++ Exception layout. A/B are ExceptionInformation[0].
namespace ABI {                                     // --------------------------------------------------------------
                                                    //
struct __cxa_exception                              // Case A: "_Unwind_Exception* A" is undependent exception:
    {                                               // --------------------------------------------------------
    union {                                         //
        struct                                      //           __cxa_exception:           std::type_info:
            {                                       //       -*--+====================+     +==================+
            ::std::type_info* exceptionType;        //        ^  |exceptionType* -----+---->|type_info data    |
            void (*exceptionDestructor)(void*);     //        |  |...                 |     |...               |
            };                                      //       -1  |                    |     +==================+
        struct                                      //        |  |                    |
            {                                       // A >----|--+--------------------+
            __cxa_exception*  primaryException;     //     |  |  |unwindHeader        |
            void (*padding)();                      //    +1  |  |                    |
            };                                      //     |  |  |                    |
        };                                          //     V  |  |                    |
                                                    //    -*---  +====================+
    std::unexpected_handler   unexpectedHandler;    //           |object              |
    std::terminate_handler    terminateHandler;     //           +--------------------+
                                                    //
    __cxa_exception*          nextException;        // Case B: "_Unwind_Exception* B" is dependent exception
    int                       handlerCount;         // (unwindHeader.exception_class & 1 != 0):
    int                       handlerSwitchValue;   // -----------------------------------------------------
    const unsigned char*      actionRecord;         //
    const unsigned char*      languageSpecificData; //           __cxa_exception:               __cxa_exception:
    void*                     catchTemp;            //       -*--+====================+     -*--+=================+
    void*                     adjustedPtr;          //        ^  |primaryException* --+--    ^  |exceptionType*   |
                                                    //        |  |...                 |  \   |  |...              |
    _Unwind_Exception         unwindHeader;         //       -1  |                    |  |   |  |                 |
    };                                              //        |  |                    |  |   |  |                 |
                                                    // B >----|--+--------------------+  |  -1  +-----------------+
struct __cxa_eh_globals                             //     |  |  |unwindHeader        |  |   |  |unwindHeader     |
    {                                               //    +1  |  |                    |  |   |  |                 |
    __cxa_exception* caughtExceptions;              //     |  |  |                    |  |   |  |                 |
    unsigned int     uncaughtExceptions;            //     V  |  |                    |  \   |  |                 |
    };                                              //    -*---  +====================+   -->*--+=================+
                                                    //           |...                 |         |object           |
} // namespace ABI                                  //           .                    .         |                 |
                                                    //                                          +-----------------+

extern "C" ABI::__cxa_eh_globals* __cxa_get_globals();

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ Hand-made IAT.
//  Some IDEs don't link with these libs by default in console projects, so do sunrise by hand. :(
//-----------------------------------------------------------------------------------------------------------------

// Hand-made DLLIMPORT helpers

#define _TX_DLLIMPORT(     lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, true)

#define _TX_DLLIMPORT_OPT( lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, false)

#define _TX_DLLIMPORT_CRT( lib, retval, name, params ) \
     retval (      * name) params = (retval (      *) params) _txDllImport (lib ".dll", #name, false)

typedef void (*_tx_FARPROC)();

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required = true);

//-----------------------------------------------------------------------------------------------------------------

namespace Win32 {

_TX_DLLIMPORT     ("GDI32",    HDC,      CreateCompatibleDC,            (HDC dc));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateCompatibleBitmap,        (HDC dc, int width, int height));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetStockObject,                (int object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  SelectObject,                  (HDC dc, HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetCurrentObject,              (HDC dc, unsigned objectType));
_TX_DLLIMPORT     ("GDI32",    int,      GetObjectA,                    (HGDIOBJ obj, int bufsize, void* buffer));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GetObjectType,                 (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteDC,                      (HDC dc));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteObject,                  (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetTextColor,                  (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetBkColor,                    (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    int,      SetBkMode,                     (HDC dc, int bkMode));
_TX_DLLIMPORT     ("GDI32",    HFONT,    CreateFontA,                   (int height, int width, int escapement, int orientation,
                                                                         int weight, DWORD italic, DWORD underline, DWORD strikeout,
                                                                         DWORD charSet, DWORD outputPrec, DWORD clipPrec,
                                                                         DWORD quality, DWORD pitchAndFamily, const char face[]));
_TX_DLLIMPORT     ("GDI32",    int,      EnumFontFamiliesExA,           (HDC dc, LPLOGFONT logFont, FONTENUMPROC enumProc,
                                                                         LPARAM lParam, DWORD reserved));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetPixel,                      (HDC dc, int x, int y, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, GetPixel,                      (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    HPEN,     CreatePen,                     (int penStyle, int width, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    HBRUSH,   CreateSolidBrush,              (COLORREF color));
_TX_DLLIMPORT     ("GDI32",    bool,     MoveToEx,                      (HDC dc, int x, int y, POINT* point));
_TX_DLLIMPORT     ("GDI32",    bool,     LineTo,                        (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    bool,     Polygon,                       (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Polyline,                      (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     PolyBezier,                    (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Rectangle,                     (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     RoundRect,                     (HDC dc, int x0, int y0, int x1, int y1, int sizeX, int sizeY));
_TX_DLLIMPORT     ("GDI32",    bool,     Ellipse,                       (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     Arc,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Pie,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Chord,                         (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     TextOutA,                      (HDC dc, int x, int y, const char string[], int length));
_TX_DLLIMPORT     ("GDI32",    UINT,     SetTextAlign,                  (HDC dc, unsigned mode));
_TX_DLLIMPORT     ("GDI32",    bool,     GetTextExtentPoint32A,         (HDC dc, const char string[], int length, SIZE* size));
_TX_DLLIMPORT     ("GDI32",    bool,     ExtFloodFill,                  (HDC dc, int x, int y, COLORREF color, unsigned type));
_TX_DLLIMPORT     ("GDI32",    bool,     BitBlt,                        (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src,  int xSrc,  int ySrc,  DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     StretchBlt,                    (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src, int xSrc, int ySrc, int wSrc, int hSrc, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     PlgBlt,                        (HDC dest, const POINT* parallelogram,
                                                                         HDC src, int xSrc, int ySrc, int width, int height,
                                                                         HBITMAP mask, int xMask, int yMask));
_TX_DLLIMPORT     ("GDI32",    int,      SetDIBitsToDevice,             (HDC dc, int xDest, int yDest, DWORD width, DWORD height,
                                                                         int xSrc, int ySrc, unsigned startLine, unsigned numLines,
                                                                         const void* data, const BITMAPINFO* info, unsigned colorUse));
_TX_DLLIMPORT     ("GDI32",    int,      GetDIBits,                     (HDC hdc, HBITMAP hbmp, unsigned uStartScan, unsigned cScanLines,
                                                                         void* lpvBits, BITMAPINFO* lpbi, unsigned usage));
_TX_DLLIMPORT     ("GDI32",    bool,     PatBlt,                        (HDC dc, int x0, int y0, int width, int height, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    int,      SetROP2,                       (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    int,      SetStretchBltMode,             (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GdiSetBatchLimit,              (DWORD limit));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateDIBSection,              (HDC dc, const BITMAPINFO* bmInfo, unsigned colorUsage, void **vBits,
                                                                         HANDLE section, DWORD offset));

_TX_DLLIMPORT     ("User32",   int,      DrawTextA,                     (HDC dc, const char text[], int length, RECT* rect, unsigned format));
_TX_DLLIMPORT     ("User32",   HANDLE,   LoadImageA,                    (HINSTANCE inst, const char name[], unsigned type,
                                                                        int sizex, int sizey, unsigned mode));
_TX_DLLIMPORT_OPT ("User32",   bool,     IsHungAppWindow,               (HWND wnd));
_TX_DLLIMPORT_OPT ("User32",   HWND,     GhostWindowFromHungWindow,     (HWND wnd));

_TX_DLLIMPORT     ("WinMM",    bool,     PlaySound,                     (const char sound[], HMODULE mod, DWORD mode));

_TX_DLLIMPORT_OPT ("MSImg32",  bool,     TransparentBlt,                (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         unsigned transparentColor));
_TX_DLLIMPORT_OPT ("MSImg32",  bool,     AlphaBlend,                    (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         BLENDFUNCTION blending));

_TX_DLLIMPORT     ("Kernel32", void,     ExitProcess,                   (unsigned retcode));
_TX_DLLIMPORT     ("Kernel32", bool,     TerminateProcess,              (HANDLE process, unsigned retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalExit,                     (int retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalAppExitA,                 (unsigned action, const char message[]));
_TX_DLLIMPORT     ("Kernel32", HWND,     GetConsoleWindow,              (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetConsoleFont,                (HANDLE con, DWORD fontIndex));
_TX_DLLIMPORT_OPT ("Kernel32", DWORD,    GetNumberOfConsoleFonts,       (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFont,         (HANDLE con, bool maxWnd, CONSOLE_FONT_INFO*   curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", void,     RtlCaptureContext,             (CONTEXT* contextRecord));
_TX_DLLIMPORT_OPT ("Kernel32", USHORT,   RtlCaptureStackBackTrace,      (DWORD framesToSkip, DWORD framesToCapture, void** backTrace, DWORD* hash));
_TX_DLLIMPORT_OPT ("Kernel32", void*,    AddVectoredExceptionHandler,   (unsigned long firstHandler, PVECTORED_EXCEPTION_HANDLER handler));
_TX_DLLIMPORT_OPT ("Kernel32", unsigned, RemoveVectoredExceptionHandler,(void* handler));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetModuleHandleEx,             (DWORD flags, const char moduleName[], HMODULE* module));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     IsWow64Process,                (HANDLE process, int* isWow64Process));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     Wow64GetThreadContext,         (HANDLE thread, WOW64_CONTEXT* context));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetThreadStackGuarantee,       (unsigned long* stackSize));

_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoInitialize,                  (void*));
_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoCreateInstance,              (REFCLSID clsId, IUnknown*, DWORD, REFIID iId, PVOID* value));
_TX_DLLIMPORT     ("OLE32",    void,     CoUninitialize,                (void));

_TX_DLLIMPORT     ("Shell32",  HINSTANCE,ShellExecuteA,                 (HWND wnd, const char operation[], const char file[],
                                                                         const char parameters[], const char directory[], int showCmd));

_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIA,                      (const char    string[], const char    search[]));
_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIW,                      (const wchar_t string[], const wchar_t search[]));

_TX_DLLIMPORT_OPT ("NTDLL",    char*,    wine_get_version,              (void));
_TX_DLLIMPORT     ("NTDLL",    NTSTATUS, NtQueryInformationProcess,     (HANDLE process, int infoClass,
                                                                         void* processInfo, unsigned long szProcessInfo, unsigned long* szReturnInfo));

_TX_DLLIMPORT_CRT ("MSVCRT",   void,     exit,                          (int retcode));
_TX_DLLIMPORT_CRT ("MSVCRT",   void,     _cexit,                        (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _fpreset,                      (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _controlfp,                    (unsigned control, unsigned mask));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthread,                  (void (__cdecl* start_address) (void*), unsigned stack_size, void* arglist));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthreadex,                (void* security, unsigned stack_size, unsigned (__stdcall* start_address) (void*),
                                                                         void *arglist, unsigned init_flag, unsigned* thread_addr));
_TX_DLLIMPORT_CRT ("MSVCRT",   char*,    __unDName,                     (char* outStr, const char* mangledName, int outStrLen,
                                                                         void* (*mallocFunc) (size_t size), void (*freeFunc) (void *pointer),
                                                                         unsigned short flags));
_TX_DLLIMPORT_CRT ("MSVCRT",   unexpected_handler, set_unexpected,      (unexpected_handler handler));

_TX_DLLIMPORT_OPT ("OpenGL32", HDC,         wglGetCurrentDC,            (void));
_TX_DLLIMPORT_OPT ("OpenGL32", unsigned,    glGetError,                 (void));
_TX_DLLIMPORT_OPT ("Glu32",    const char*, gluErrorString,             (unsigned error));

_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     MiniDumpWriteDump,             (HANDLE process, DWORD processId, HANDLE file, MINIDUMP_TYPE dumpType,
                                                                         MINIDUMP_EXCEPTION_INFORMATION*   exceptionParam,
                                                                         MINIDUMP_USER_STREAM_INFORMATION* userStreamParam,
                                                                         MINIDUMP_CALLBACK_INFORMATION*    callbackParam));

_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("DbgHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
namespace MinGW {
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("MgwHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
} // namespace MinGW

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal function prototypes, macros and constants
//  @name    Ïðîòîòèïû âíóòðåííèõ ôóíêöèé, ìàêðîñû è êîíñòàíòû
//=================================================================================================================
//! @{

const int        _TX_IDM_ABOUT                            =   40000,       // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
                 _TX_IDM_CONSOLE                          =   40001,
                 _TX_WM_CREATEWND                         =   0x7FF0,      // Ñîîáùåíèÿ äëÿ ñîçäàíèÿ/óíè÷òîæåíèÿ
                 _TX_WM_DESTROYWND                        =   0x7FF1;      // îêîí â ïîòîêå Canvas

//-----------------------------------------------------------------------------------------------------------------

int              _txInitialize();
void             _txCleanup();

HWND             _txCanvas_CreateWindow      (const SIZE* size);
inline bool      _txCanvas_OK() tx_nodiscard;

bool             _txCanvas_OnCREATE          (HWND wnd);
bool             _txCanvas_OnDESTROY         (HWND wnd);
bool             _txCanvas_OnCLOSE           (HWND);
bool             _txCanvas_OnPAINT           (HWND wnd);
bool             _txCanvas_OnKEYDOWN         (HWND wnd, WPARAM vk, LPARAM info);
bool             _txCanvas_OnCHAR            (HWND wnd, WPARAM ch, LPARAM info);
bool             _txCanvas_OnTIMER           (HWND wnd, WPARAM id);
bool             _txCanvas_OnMOUSEMOVE       (HWND wnd, WPARAM buttons, LPARAM coords);
bool             _txCanvas_OnMOUSELEAVE      (HWND wnd);
bool             _txCanvas_OnCREATEWND       (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnDESTROYWND      (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnCmdCONSOLE      (HWND wnd, WPARAM cmd);
bool             _txCanvas_OnCmdABOUT        (HWND wnd, WPARAM cmd);

unsigned WINAPI  _txCanvas_ThreadProc        (void* data);
LRESULT CALLBACK _txCanvas_WndProc           (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);

int              _txCanvas_SetRefreshLock    (int count);

HDC              _txBuffer_Create            (HWND wnd = NULL, const POINT* size = NULL, HBITMAP bitmap = NULL,
                                              RGBQUAD** pixels = NULL) tx_nodiscard;
bool             _txBuffer_Delete            (HDC* dc);
bool             _txBuffer_Select            (HGDIOBJ obj, HDC dc = txDC());

HWND             _txConsole_Attach();
bool             _txConsole_OK() tx_nodiscard;
bool             _txConsole_Detach           (bool activate);
bool             _txConsole_Draw             (HDC dc);
bool             _txConsole_SetUnicodeFont();

const char*       txRegisterClass            (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra);
HWND              txCreateExtraWindow        (CREATESTRUCT createData);
HICON            _txCreateTXIcon             (int size) tx_nodiscard;
int              _txSetFinishedText          (HWND wnd);
void             _txPauseBeforeTermination   (HWND canvas);
int              _txIsParentWaitable         (DWORD* parentPID = NULL) tx_nodiscard;
int              _txGetInput();

LRESULT CALLBACK _txPlayVideo_WndProc        (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
const char*      _txPlayVideo_FindVLC() tx_nodiscard;

bool             _txCreateShortcut           (const char shortcutName[],
                                              const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
                                              const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
                                              const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
                                              COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));

void*            _tx_DLGTEMPLATE_Create      (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                                              WORD controls, short x, short y, short cx, short cy,
                                              const char caption[], const char font[], WORD fontsize,
                                              const char menu[]) tx_nodiscard;

void*            _tx_DLGTEMPLATE_Add         (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                                              short x, short y, short cx, short cy,
                                              WORD id, const char wclass[], const char caption[]);

const char*      _txError                    (const char file[] = NULL, int line = 0, const char func[] = NULL, unsigned color = 0,
                                              const char msg[] = NULL, ...) tx_printfy (5);
const char*      _txProcessError             (const char file[], int line, const char func[], unsigned color,
                                              const char msg[], va_list args);
void             _txOnTerminate();
void             _txOnUnexpected();
void             _txOnPureCall();
void             _txOnNewHandlerAnsi();
int              _txOnNewHandler             (size_t size);
void             _txOnSignal                 (int signal = 0, int fpe = 0);
BOOL WINAPI      _txOnConsoleCtrlEvent       (DWORD type);
void             _txOnSecurityError          (int code, void*);
void             _txOnSecurityErrorAnsi      (const char* msg, void* ptr, int code);
int              _txOnMatherr                (_exception* except);
void             _txOnInvalidParam           (const wchar_t* expr, const wchar_t* func, const wchar_t* file,
                                              unsigned line, uintptr_t);
int              _txOnAllocHook              (int type, void* data, size_t size, int use, long request,
                                              const unsigned char* file, int line);
int              _txOnRTCFailure             (int type, const char* file, int line, const char* module, const char* format, ...) tx_printfy (5);
int              _txOnErrorReport            (int type, const char* text, int* ret);
int               tx_glGetError              (int setError = INT_MIN);

void             _txOnCExit();
void             _txOnExit                   (int      retcode);
void             _txOnFatalExit              (int      retcode);
void             _txOnExitProcess            (unsigned retcode);
void             _txOnFatalAppExitA          (unsigned action, const char message[]);
bool             _txOnTerminateProcess       (HANDLE process, unsigned retcode);
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
                 _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter);
void             _txWatchdogTerminator       (void* timeout);  // Only Arnold-type series are supported, not T1000

long WINAPI      _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc);
long WINAPI      _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc);
long             _txOnExceptionSEH           (EXCEPTION_POINTERS* exc, const char func[]);
intptr_t         _txDumpExceptionSEH         (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[]);
intptr_t         _txDumpExceptionObj         (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type);
intptr_t         _txDumpExceptionCPP         (char what[], intptr_t size, unsigned code = 0,
                                              unsigned params = 0, const ULONG_PTR info[] = NULL);

void             _txStackBackTrace           (const char file[] = "?", int line = 0, const char func[] = "?",
                                              bool readSource = true);
const char*      _txCaptureStackBackTrace    (int framesToSkip = 0, bool readSource = true,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
int              _txStackWalk                (int framesToSkip, size_t szCapture, void* capture[], unsigned long* backTraceHash,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
const char*      _txCaptureStackBackTraceTX  (int framesToSkip = 0, bool readSource = false);

const char*      _txSymPrintFromAddr         (void* addr = NULL, const char format[] = NULL, ...) tx_printfy (2);
bool             _txSymGetFromAddr           (void* addr, Win32::SYMBOL_INFO** symbol = NULL,
                                              Win32::IMAGEHLP_LINE64** line = NULL, const char** module = NULL,
                                              const char** source = NULL, int context = 2);
intptr_t         _txReadSource               (char buf[], intptr_t size, const char file[],
                                              int linStart = 0, int linEnd = INT_MIN, int linMark = INT_MIN);
bool             _txCreateMiniDump           (EXCEPTION_POINTERS* exc);

uintptr_t        _txSetProcAddress           (const char funcName[], uintptr_t newFunc, const char dllName[] = NULL,
                                              int useHotPatching = false, HMODULE module = NULL, bool debug = false);
bool             _txInDll() tx_nodiscard;
PROCESSENTRY32*  _txFindProcess              (unsigned pid = GetCurrentProcessId()) tx_nodiscard;
bool             _txKillProcess              (DWORD pid);
bool             _txIsBadReadPtr             (const void* address);
bool             _txCheckSourceCP            (int needCP = _TX_CODEPAGE, bool verbose = true);
bool             _txGetCommandLine           (wchar_t cmdLine[], size_t szCmdLine, unsigned pid = _getpid());
IMAGE_NT_HEADERS*_txGetNtHeaders             (HMODULE module = GetModuleHandle (NULL)) tx_nodiscard;
const char*      _txAppInfo() tx_nodiscard;

intptr_t         _tx_snprintf_s              (char stream[], intptr_t size, const char format[], ...) tx_printfy (3);
intptr_t         _tx_vsnprintf_s             (char stream[], intptr_t size, const char format[], va_list arg);
void              txReopenStdio();

#if defined (_CLANG_VER) && !defined (_MSC_VER)
void             _txLibCppDebugFunction      (std::__libcpp_debug_info const& info);
#endif

#if defined (__CYGWIN__)

int              _getch();
int              _putch (int ch);
int              _kbhit() tx_nodiscard;

#endif

//-----------------------------------------------------------------------------------------------------------------
// There are macros for __FILE__ and __LINE__ to work properly.

#if !defined (NDEBUG)

    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) && \
                                                     (assert (cond), true) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå."), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("Ïàðàìåòð \"%s\" íåâåðåí. Âîçìîæíî, ýòîò õîëñò íå ñîçäàí, " \
                                                                "èëè óæå óíè÷òîæåí, èëè íå çàãðóçèëàñü êàðòèíêà.", #dc), 1) )
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( (!(dc) &&                                           \
                                                     _TX_TXWINDOW_FAILED()) || _TX_HDC_FAILED (dc) )

#else
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define _TX_DEFAULT_HDC_FAILED(dc)         ( !(dc) &&                                            \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
#endif

//-----------------------------------------------------------------------------------------------------------------
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but MSVC rejects it. So sad. :'(

#if !defined (NDEBUG)
    #define  _TX_ON_DEBUG( code )              { code; }
#else
    #define  _TX_ON_DEBUG( code )              ;
#endif

//-----------------------------------------------------------------------------------------------------------------
// Invokes an error without location information. "$$" restores TX-related call location context

#define _TX_UNEXPECTED( ... )                  $$ _txError (NULL, 0, NULL, 0, ##__VA_ARGS__)

//-----------------------------------------------------------------------------------------------------------------
// Safe call of a function via its pointer

#define _TX_CALL(  func, param )               ( (func)? ((func) param) :       0 )
#define _TX_CALLv( func, param )               ( (func)? ((func) param) : (void)0 )

//-----------------------------------------------------------------------------------------------------------------
// This is a macro because cond is an expression and is not always a function. Lack of lambdas in pre-C++0x.

#define      _txWaitFor( cond, time )          { for (DWORD _t = GetTickCount() + (time); \
                                                      !(cond) && GetTickCount() < _t;     \
                                                      Sleep (_txWindowUpdateInterval)) ;  \
                                                 if  (!(cond))                            \
                                                      _txTrace (__FILE__, __LINE__, NULL, "WARNING: Timeout: " #cond "."); }
//-----------------------------------------------------------------------------------------------------------------
// Detouring in case of SEH mechanism

#define _txSetJmp()                            ( setjmp (_txDumpExceptionObjJmp) == 0 )

#define _txClearJmp()                          { *(unsigned long long*) _txDumpExceptionObjJmp = 0; }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal global data
//! @name    Âíóòðåííèå ãëîáàëüíûå äàííûå
//
//           Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
//           Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåð, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
//           Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
//           Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé, èëè êëàññ.
//=================================================================================================================
//! @{

int                          _txInitialized              = _TX_NOINIT || _txInitialize();

volatile const unsigned      _txCanaryFirst              = 0x776F656D; // A very system value

volatile unsigned            _txMainThreadId             = 0;          // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
volatile HANDLE              _txMainThread               = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà

volatile unsigned            _txCanvas_ThreadId          = 0;          // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
volatile HANDLE              _txCanvas_Thread            = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
volatile HWND                _txCanvas_Window            = NULL;       // Äåñêðèïòîð îêíà õîëñòà TXLib

HDC                          _txCanvas_BackBuf[2]        = {NULL,      // [0] Main TXLib in-memory DC, where user's pictures lies
                                                            NULL};     // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()

RGBQUAD*                     _txCanvas_Pixels            = NULL;       // Memory buffer of _txCanvas_BackBuf[0]

HBITMAP                      _txStockBitmap              = NULL;       // Equivalent of GetStockObject (BITMAP),
                                                                       // see https://devblogs.microsoft.com/oldnewthing/20100416-00/?p=14313

CRITICAL_SECTION             _txCanvas_LockBackBuf       = {0,-1};     // Prevent simultaneous access to back buffer, see txLock()

UINT_PTR                     _txCanvas_RefreshTimer      = 1;          // Timer ID to redraw TXLib window
volatile int                 _txCanvas_RefreshLock       = 0;          // Blocks auto on-timer canvas update, see txBegin/txEnd

::std::vector<HDC>*          _txCanvas_UserDCs           = NULL;       // List of DCs allocated, for auto-free

volatile bool                _txConsole_IsBlinking       = true;       // To blink or not to blink, that is the question.

bool                         _txConsole                  = false;      // Only first TXLib module in app can own the console
bool                         _txMain                     = false;      // First TXLib wnd opened (closing it terminates program)
bool                         _txIsDll                    = false;      // TXLib module is in DLL
volatile bool                _txRunning                  = false;      // main() is still running
volatile bool                _txExit                     = false;      // exit() is active

volatile POINT               _txMousePos                 = {-1,-1};    // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
volatile unsigned            _txMouseButtons             = 0;

volatile WNDPROC             _txAltWndProc               = NULL;       // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().

_tx_thread _txLoc            _txLoc::Cur                 = {};         // Execution point tracking and trace state, see "$" macro

volatile int                 _txErrors                   = 0;          // TX_ERROR calls sequental number
int                          _txOGLError                 = 0;          // Last OpenGL error when using tx_glGetError()
volatile long                _txSENumber                 = 0;          // SEH exceptions sequental number
volatile long                _txSEFatalNumber            = 0;          // SEH fatal exceptions sequental number
char                         _txDumpSE [_TX_BUFSIZE]     = "";         // SEH dump data area
char                         _txTraceSE[_TX_HUGEBUFSIZE] = "";         // Stack trace data area

LPTOP_LEVEL_EXCEPTION_FILTER _txPrevUEFilter             = NULL;       // Previous UnhandledExceptionFilter

jmp_buf                      _txDumpExceptionObjJmp      = {};         // Hook for _txDumpExceptionObj

const volatile uintptr_t     _txForceImport[]            = { (uintptr_t) ::TerminateProcess,              (uintptr_t) ::ExitProcess,
                                                             (uintptr_t) ::FatalExit,                     (uintptr_t) ::FatalAppExitA,
                                                             (uintptr_t) ::exit,                          (uintptr_t) Win32::_controlfp,
                                                             (uintptr_t) Win32::Polyline,                 (uintptr_t) Win32::PolyBezier,
                                                             (uintptr_t) Win32::RoundRect,                (uintptr_t) Win32::RemoveVectoredExceptionHandler,
                                                             (uintptr_t) Win32::PlgBlt,                   (uintptr_t) Win32::RtlCaptureStackBackTrace,
                                                             (uintptr_t) Win32::SymInitialize,            (uintptr_t) Win32::MinGW::SymInitialize,
                                                             (uintptr_t) Win32::SymSetOptions,            (uintptr_t) Win32::MinGW::SymSetOptions,
                                                             (uintptr_t) Win32::SymGetLineFromAddr64,     (uintptr_t) Win32::MinGW::SymGetLineFromAddr64,
                                                             (uintptr_t) Win32::SymFromAddr,              (uintptr_t) Win32::MinGW::SymFromAddr,
                                                             (uintptr_t) Win32::SymCleanup,               (uintptr_t) Win32::MinGW::SymCleanup,
                                                             (uintptr_t) Win32::SymGetModuleBase64,       (uintptr_t) Win32::MinGW::SymGetModuleBase64,
                                                             (uintptr_t) Win32::SymFunctionTableAccess64, (uintptr_t) Win32::MinGW::SymFunctionTableAccess64,
                                                             (uintptr_t) Win32::StackWalk64,              (uintptr_t) Win32::MinGW::StackWalk64,
                                                             (uintptr_t) Win32::StrStrIA,                 (uintptr_t) Win32::Wow64GetThreadContext };

volatile const unsigned      _txCanaryLast               = 0x5E2E2E5E; // Another very system value

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib engine init/check/cleanup
//! @name    Èíèöèàëèçàöèÿ/ïðîâåðêà/çàâåðøåíèå TXLib
//=================================================================================================================
//! @{

//-----------------------------------------------------------------------------------------------------------------
//{          Early initialization
//-----------------------------------------------------------------------------------------------------------------

int _txInitialize()
    {
    if (_txInitialized) return 1;
    _txInitialized = 1;

    #if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)  // See http://msdn.microsoft.com/en-us/library/w2fhc9a3%28v=vs.90%29.aspx
    _CrtSetBreakAlloc (_TX_ALLOC_BREAK);                 // and http://support.microsoft.com/ru-ru/kb/151585
    #endif

    #if defined (_TX_ALLOW_TRACE)
    _txLocLvlSet (1);
    #endif

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
                                     "compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

    _txMainThreadId = GetCurrentThreadId();
    _txMainThread   = OpenThread (THREAD_ALL_ACCESS, false, _txMainThreadId);

$3  _txIsDll = _txInDll();

$   if (!_txIsDll)
        {
$       _txConsole = ! FindAtom ("_txConsole");
$       (void)          AddAtom ("_txConsole");
        }

$   if (_txConsole)
        {
$       _txCheckSourceCP (_TX_CODEPAGE, true);

$       unsigned long stackSize = _TX_STACKSIZE;
$       _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$       _txOnSignal();

$       if (!*_txLogName)
            {$ _tx_snprintf_s (_txLogName, sizeof (_txLogName) - 1, "%s.log", txGetModuleFileName()); }

$       if (!_txIsDll)
            {
$           _TX_CALL  (Win32::AddVectoredExceptionHandler, (1, (PVECTORED_EXCEPTION_HANDLER)  _txVectoredExceptionHandler));
$           _txPrevUEFilter = SetUnhandledExceptionFilter  (   (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter);
            }

$       ::std::set_terminate             (_txOnTerminate);
$       ::std::set_new_handler           (_txOnNewHandlerAnsi);
$       _TX_CALL (Win32::set_unexpected, (_txOnUnexpected));

        #if defined (_CLANG_VER) && !defined (_MSC_VER)
$       ::std::__libcpp_debug_function = _txLibCppDebugFunction;
        #endif

$       SetConsoleCtrlHandler (_txOnConsoleCtrlEvent, true);

$       SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);

        #if defined (_MSC_VER)

$       _set_printf_count_output (1);

$       _set_new_handler (_txOnNewHandler);
$       _set_new_mode (1);

        #if !defined (_CLANG_VER)

$       _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$       _CrtSetAllocHook (_txOnAllocHook);

$       unsigned mode = _CRTDBG_MODE_FILE;
$       if (_CrtSetReportHook2 (_CRT_RPTHOOK_INSTALL, (_CRT_REPORT_HOOK) _txOnErrorReport) > 0) mode = 0;

$       _CrtSetReportMode (_CRT_WARN,   _CRTDBG_MODE_DEBUG | mode);
$       _CrtSetReportMode (_CRT_ERROR,  _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportFile (_CRT_WARN,   _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ERROR,  _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);

        #endif

$       _set_abort_behavior (_WRITE_ABORT_MSG, _WRITE_ABORT_MSG);
$       _set_abort_behavior (0,                _CALL_REPORTFAULT);

$       _RTC_SetErrorFunc              (_txOnRTCFailure);
$       _set_purecall_handler          (_txOnPureCall);
$       _set_invalid_parameter_handler (_txOnInvalidParam);

        #endif

        #if defined (__STDC_LIB_EXT1__)
$       ::std::set_constraint_handler_s (_txOnSecurityErrorAnsi);
        #endif

        #if !defined (__CYGWIN__) && defined (_GCC_VER) && (_GCC_VER >= 530) && !defined (i386)
$       __setusermatherr (_txOnMatherr);
        #endif

        #if !defined (__CYGWIN__)
$       _set_error_mode (_OUT_TO_MSGBOX | _OUT_TO_STDERR);
        #endif

$       HWND console = _txConsole_Attach();
$       SetWindowTextA (console, txGetModuleFileName (false));
        }

$   InitializeCriticalSection (&_txCanvas_LockBackBuf);

$   _txSetProcAddress ("ExitProcess",                 (uintptr_t) _txOnExitProcess,                 "KERNEL32.DLL");
$   _txSetProcAddress ("TerminateProcess",            (uintptr_t) _txOnTerminateProcess,            "KERNEL32.DLL");
$   _txSetProcAddress ("FatalExit",                   (uintptr_t) _txOnFatalExit,                   "KERNEL32.DLL");
$   _txSetProcAddress ("FatalAppExitA",               (uintptr_t) _txOnFatalAppExitA,               "KERNEL32.DLL");
$   _txSetProcAddress ("UnhandledExceptionFilter",    (uintptr_t) _txUnhandledExceptionFilter,      "KERNEL32.DLL", true);
$   _txSetProcAddress ("SetUnhandledExceptionFilter", (uintptr_t) _txOnSetUnhandledExceptionFilter, "KERNEL32.DLL");
$   _txSetProcAddress ("exit",                        (uintptr_t) _txOnExit);
$   _txSetProcAddress ("_cexit",                      (uintptr_t) _txOnCExit);

$   atexit (_txCleanup);

$   if (_txConsole)
        {
$       txSetConsoleAttr (FOREGROUND_LIGHTGRAY);

$       tx_fpreset();

$       srand ((unsigned) time (NULL));

$       SetLastError (0);
$       errno = 0;

        #if !defined (__CYGWIN__)
$       _doserrno = 0;
        #endif
        }

$   HDC dc = Win32::CreateCompatibleDC (NULL); dc asserted;
$   _txStockBitmap = (HBITMAP) Win32::SelectObject (dc, Win32::CreateCompatibleBitmap (dc, 1, 1)); _txStockBitmap asserted;
$   Win32::DeleteObject (Win32::SelectObject (dc, _txStockBitmap)) asserted;
$   Win32::DeleteDC (dc) asserted;

$   return 1;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCheckSourceCP (int needCP /*= _TX_CODEPAGE*/, bool verbose /*= true*/)
    {
$3  const char* sCodePage = NULL;
$   int codePage = 0;

$   switch (((unsigned const char*) "À") [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }

$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please

$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }

$   return (codePage == needCP);
    }

//-----------------------------------------------------------------------------------------------------------------

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;

    static char dllPaths [2][MAX_PATH] = {"", ""};

    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";

        // dllPaths[0] is relative to the TX Setup directory stored in the Registry

        char* path = dllPaths[0];

        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);

        // dllPaths[1] is relative to TXib.h file used in compilation

        path = dllPaths[1];

        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }

        if (char* dir = strrchr (path, '\\')) *dir = 0;

        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }

    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);

    if (arch)
        {
        assert (arch >= dllFileName);

        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));

        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }

    HMODULE   dll = GetModuleHandle (dllFileName);

    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);

    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);

        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);

        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }

    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);

    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;

    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);

    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè
#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
    //                      |          | ýëåìåíòà  | X | Y |Øèð.|Âûñ.| îêîí äèàëîãà â MSDN)
    //----------------------+----------+-----------+---+---+----+----+---------------------------------------------
    //                      |          |           |   |   |    |    |
        {{ txDialog::DIALOG,  caption,   0,           0,  0, 240,  85                                                    },
         { txDialog::STATIC,  text,      ID_TEXT_,   10, 10, 150,  40, SS_LEFT                                           },
         { txDialog::EDIT,    input,     ID_INPUT_,  10, 60, 220,  15, ES_LEFT | WS_BORDER | ES_AUTOHSCROLL | WS_TABSTOP },
         { txDialog::BUTTON,  "&OK",     IDOK,      180, 10,  50,  15, BS_DEFPUSHBUTTON                     | WS_TABSTOP },
         { txDialog::BUTTON,  "&Cancel", IDCANCEL,  180, 30,  50,  15, BS_PUSHBUTTON                        | WS_TABSTOP },
         { txDialog::END                                                                                                 }};
 
    //-------------------------------------------------------------------------------------------------------------
    // Êëàññ äèàëîãà äëÿ InputBox. Âíóòðåííèé, ò.ê. çà÷åì åìó áûòü âíåøíèì.
    // Íóæåí â îñíîâíîì äëÿ çàäàíèÿ ñòðîêè ââîäà (str) è îêîííîé ôóíêöèè äèàëîãîâîãî îêíà, òðåáóåìîé Win32 (îíà    // ïîñòðîåíà ìàêðîñàìè TX_BEGIN_MESSAGE_MAP è äðóãèìè). Ìîæíî íå äåëàòü âíóòðåííåãî êëàññà, íî òîãäà îêîííóþ
    // ôóíêöèþ ïðèäåòñÿ ïèñàòü â ãëîáàëüíîé îáëàñòè âèäèìîñòè, è str îáúÿâëÿòü ãëîáàëüíî òîæå (èëè ïåðåäàâàòü åå
    // àäðåñ ÷åðåç DialogBoxParam è çàïèñûâàòü åãî â êëàññ âî âðåìÿ îáðàáîòêè WM_INITDIALOG).
    //-------------------------------------------------------------------------------------------------------------
    struct inputDlg : txDialog
        {
        char str [1024];

        //---------------------------------------------------------------------------------------------------------

        inputDlg() :
            str()
            {}

        //---------------------------------------------------------------------------------------------------------

        TX_BEGIN_MESSAGE_MAP()    // Êàðòà ñîîáùåíèé (íà ñàìîì äåëå ýòî íà÷àëî îêîííîé ôóíêöèè).

            TX_COMMAND_MAP        // Çäåñü îáðàáàòûâàþòñÿ WM_COMMAND (íà ñàìîì äåëå ýòî îïåðàòîð switch).

                //-------------------------------------------------------------------------------------------------
                // Ïðè íàæàòèè êíîïêè OK êîïèðóåì ñòðîêó èç ïîëÿ ââîäà â íàøó ïåðåìåííóþ str, ò.ê. ïîñëå çàêðûòèÿ
                // äèàëîãà ñòðîêà ââîäà óìðåò è òåêñò óæå èç íåå ïîëó÷èòü.
                // Ýòîò ìàêðîñ íà ñàìîì äåëå ïðåâðàùàåòñÿ â case èç îïåðàòîðà switch.
                // _wnd -- ýòî ïàðàìåòð îêîííîé ôóíêöèè, ñì. îïðåäåëåíèå ìàêðîñà TX_BEGIN_MESSAGE_MAP().
                //-------------------------------------------------------------------------------------------------

                TX_HANDLE (IDOK) GetDlgItemText (_wnd, ID_INPUT_, str, sizeof (str) - 1);

        TX_END_MESSAGE_MAP

        //---------------------------------------------------------------------------------------------------------
        // Êîíåö âíóòðåííåãî êëàññà äèàëîãà
        //---------------------------------------------------------------------------------------------------------
        };

    //-------------------------------------------------------------------------------------------------------------
    // Óáèðàåì äåôàéíû, ÷òîáû ïîòîì íå ìåøàëè.
    // Îò ýòîãî îíè ïîëó÷àþòñÿ "ëîêàëüíîãî äåéñòâèÿ", êàê áóäòî ó íèõ áûëà áû îáëàñòü âèäèìîñòè -- ôóíêöèÿ. Íà ñàìîì
    // äåëå ýòî ñäåëàíî âðó÷íóþ ÷åðåç #undef. ×òîáû ïîä÷åðêíóòü èõ ëîêàëüíóþ ïðèðîäó, ó íèõ èìåíà çàêàí÷èâàþòñÿ íà _.
    // Òàêèå äåôàéíû ïîòîì íå ïåðåêîñÿ÷àò âåñü êîä ïîñëå òîãî êàê, ôàêòè÷åñêè, ñòàëè óæå íå íóæíû.
    //-------------------------------------------------------------------------------------------------------------

    #undef ID_TEXT_
    #undef ID_INPUT_

    //-------------------------------------------------------------------------------------------------------------
    // Ýòî ñòàòè÷åñêèé îáúåêò, ïîòîìó ÷òî ñòðîêà â íåì äîëæíà æèòü ïîñëå çàâåðøåíèÿ ôóíêöèè.
    //-------------------------------------------------------------------------------------------------------------

    static inputDlg dlg;

    //-------------------------------------------------------------------------------------------------------------
    // Ïåðåäàåì layout è çàïóñêàåì îêíî äèàëîãà
    //-------------------------------------------------------------------------------------------------------------

    dlg.dialogBox (layout);

    //-------------------------------------------------------------------------------------------------------------
    // Âîçâðàùàåì àäðåñ ñòðîêè èç ñòàòè÷åñêîãî îáúåêòà. Òàê ìîæíî äåëàòü, ïîòîìó ÷òî ñòàòè÷åñêèé îáúåêò íå óìðåò
    // ïðè âûõîäå èç ôóíêöèè è ñòðîêà â íåì, ñîîòâåòñòâåííî, òîæå. Àäðåñ íåñòàòè÷åñêèõ ïåðåìåííûõ ïåðåäàâàòü
    // ñèíòàêñè÷åñêè ìîæíî, íî âåäåò ê ñåðüåçíûì îøèáêàì.
    //-------------------------------------------------------------------------------------------------------------

    return dlg.str;
    }

//! @}
//}
//=================================================================================================================

//}
//=================================================================================================================

//=================================================================================================================
//{          TXLIB IMPLEMENTATION
//           Ðåàëèçàöèÿ ôóíêöèé áèáëèîòåêè
//=================================================================================================================
//! @cond INTERNAL

//=================================================================================================================
//{          DLL functions import, missing types definitions
//! @name    Èìïîðò âíåøíèõ áèáëèîòåê, îïðåäåëåíèå íåäîñòàþùèõ òèïîâ
//=================================================================================================================
//! @{

namespace Win32 {

//-----------------------------------------------------------------------------------------------------------------
//{ Some of structs, consts and interfaces aren't defined in MinGW some early headers.
//  Copied from Windows SDK 7.0a.
//-----------------------------------------------------------------------------------------------------------------

#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                             0x01
#endif

#ifndef SMTO_ERRORONEXIT
#define SMTO_ERRORONEXIT                         0x0020
#endif

#ifndef NT_CONSOLE_PROPS_SIG
#define NT_CONSOLE_PROPS_SIG                     0xA0000002
#endif

#ifndef NIIF_INFO
#define NIIF_INFO                                0x00000001
#define NIIF_WARNING                             0x00000002
#define NIIF_ERROR                               0x00000003
#endif

#ifndef NIF_INFO
#define NIF_STATE                                0x00000008
#define NIF_INFO                                 0x00000010
#endif

#ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
#define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS   0x00000004
#endif

#ifndef SYMOPT_CASE_INSENSITIVE
#define SYMOPT_CASE_INSENSITIVE                  0x00000001
#define SYMOPT_UNDNAME                           0x00000002
#define SYMOPT_DEFERRED_LOADS                    0x00000004
#define SYMOPT_NO_CPP                            0x00000008
#define SYMOPT_LOAD_LINES                        0x00000010
#define SYMOPT_OMAP_FIND_NEAREST                 0x00000020
#define SYMOPT_LOAD_ANYTHING                     0x00000040
#define SYMOPT_IGNORE_CVREC                      0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS              0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS              0x00000200
#define SYMOPT_EXACT_SYMBOLS                     0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS            0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH                 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES             0x00002000
#define SYMOPT_PUBLICS_ONLY                      0x00004000
#define SYMOPT_NO_PUBLICS                        0x00008000
#define SYMOPT_AUTO_PUBLICS                      0x00010000
#define SYMOPT_NO_IMAGE_SEARCH                   0x00020000
#define SYMOPT_SECURE                            0x00040000
#define SYMOPT_NO_PROMPTS                        0x00080000
#define SYMOPT_ALLOW_ZERO_ADDRESS                0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT         0x02000000
#define SYMOPT_FAVOR_COMPRESSED                  0x00800000
#define SYMOPT_FLAT_DIRECTORY                    0x00400000
#define SYMOPT_IGNORE_IMAGEDIR                   0x00200000
#define SYMOPT_OVERWRITE                         0x00100000
#define SYMOPT_DEBUG                             0x80000000
#endif

// SEH exception codes. For GCC, see http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 64-66.

#ifndef STATUS_POSSIBLE_DEADLOCK
#define STATUS_POSSIBLE_DEADLOCK                 0xC0000194
#endif

#ifndef STATUS_FLOAT_MULTIPLE_FAULTS
#define STATUS_FLOAT_MULTIPLE_FAULTS             0xC00002B4
#endif

#ifndef STATUS_STACK_BUFFER_OVERRUN
#define STATUS_STACK_BUFFER_OVERRUN              0xC0000409
#endif

#ifndef STATUS_ASSERTION_FAILURE
#define STATUS_ASSERTION_FAILURE                 0xC0000420
#endif

#ifndef STATUS_WX86_BREAKPOINT
#define STATUS_WX86_BREAKPOINT                   0x4000001F
#endif

#ifndef DBG_PRINTEXCEPTION_C
#define DBG_PRINTEXCEPTION_C                     0x40010006  // OutputDebugStringA() call
#endif

#ifndef DBG_PRINTEXCEPTION_WIDE_C
#define DBG_PRINTEXCEPTION_WIDE_C                0x4001000A  // OutputDebugStringW() call
#endif

#ifndef DBG_THREAD_NAME
#define DBG_THREAD_NAME                          0x406D1388
#endif

#define EXCEPTION_CPP_MSC                        0xE06D7363  // '?msc'
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1       0x19930520  // '?msc' version magic, see ehdata.h
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2       0x19930521  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3       0x19930522  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1  0x01994000  // '?msc' version magic

#define EXCEPTION_CPP_GCC                        0x20474343  // ' GCC'
#define EXCEPTION_CPP_GCC_UNWIND                 0x21474343  // '!GCC'
#define EXCEPTION_CPP_GCC_FORCED                 0x22474343  // '"GCC'

#define EXCEPTION_CLR_FAILURE                    0xE0434f4D  // 'àCOM'

#define EXCEPTION_CPP_BORLAND_BUILDER            0x0EEDFAE6  // Should never occur here
#define EXCEPTION_CPP_BORLAND_DELPHI             0x0EEDFADE  // Should never occur here

#pragma pack (push, 1)

struct CONSOLE_CURSOR_INFO
    {
    DWORD dwSize;
    BOOL bVisible;
    };

struct CONSOLE_FONT_INFO
    {
    DWORD nFont;
    COORD dwFontSize;
    };

struct CONSOLE_FONT_INFOEX
    {
    ULONG cbSize;
    DWORD nFont;
    COORD dwFontSize;
    UINT  FontFamily;
    UINT  FontWeight;
    WCHAR FaceName[LF_FACESIZE];
    };

struct DATABLOCK_HEADER
    {
    DWORD cbSize;
    DWORD dwSignature;
    };

struct NT_CONSOLE_PROPS
    {
    DATABLOCK_HEADER dbh;

    WORD  wFillAttribute;
    WORD  wPopupFillAttribute;
    COORD dwScreenBufferSize;
    COORD dwWindowSize;
    COORD dwWindowOrigin;
    DWORD nFont;
    DWORD nInputBufferSize;
    COORD dwFontSize;
    UINT  uFontFamily;
    UINT  uFontWeight;
    WCHAR FaceName[LF_FACESIZE];
    UINT  uCursorSize;
    BOOL  bFullScreen;
    BOOL  bQuickEdit;
    BOOL  bInsertMode;
    BOOL  bAutoPosition;
    UINT  uHistoryBufferSize;
    UINT  uNumberOfHistoryBuffers;
    BOOL  bHistoryNoDup;

    COLORREF ColorTable[16];
    };

#pragma pack (pop)

#undef  INTERFACE
#define INTERFACE IShellLinkDataList

DECLARE_INTERFACE_ (IShellLinkDataList, IUnknown)
    {
    // *** IUnknown methods ***
    STDMETHOD (QueryInterface)  (THIS_ REFIID iid, void** value)    _tx_override PURE;
    STDMETHOD_(ULONG, AddRef)   (THIS)                              _tx_override PURE;
    STDMETHOD_(ULONG, Release)  (THIS)                              _tx_override PURE;

    // *** IShellLinkDataList methods ***
    STDMETHOD (AddDataBlock)    (THIS_ void* dataBlock)             PURE;
    STDMETHOD (CopyDataBlock)   (THIS_ DWORD sig, void** dataBlock) PURE;
    STDMETHOD (RemoveDataBlock) (THIS_ DWORD sig)                   PURE;
    STDMETHOD (GetFlags)        (THIS_ DWORD* flags)                PURE;
    STDMETHOD (SetFlags)        (THIS_ DWORD  flags)                PURE;

    protected:
    virtual ~IShellLinkDataList();
    };

const GUID IID_IShellLink         = {0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID IID_IShellLinkDataList = {0x45e2b4ae, 0xb1c3, 0x11d0, {0xb9,0x2f,0x00,0xa0,0xc9,0x03,0x12,0xe1}};
const GUID IID_IPersistFile       = {0x0000010b, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};

const GUID CLSID_SpVoice          = {0x96749377, 0x3391, 0x11d2, {0x9e,0xe3,0x00,0xc0,0x4f,0x79,0x73,0x96}};
const GUID IID_ISpVoice           = {0x6c44df74, 0x72b9, 0x4992, {0xa1,0xec,0xef,0x99,0x6e,0x04,0x22,0xd4}};

#undef  INTERFACE

typedef DWORD     NTSTATUS;
typedef ULONG_PTR KAFFINITY;
typedef LONG      KPRIORITY;

struct UNICODE_STRING
    {
    USHORT Length;
    USHORT MaximumLength;
    WCHAR* Buffer;
    };

struct RTL_USER_PROCESS_PARAMETERS
    {
    BYTE  Reserved1[16];
    void* Reserved2[10];
    UNICODE_STRING ImagePathName;
    UNICODE_STRING CommandLine;
    };

struct PEB
    {
    BYTE  Reserved1[2];
    BYTE  BeingDebugged;
    BYTE  Reserved2[1];
    void* Reserved3[2];
    void* Ldr;
    RTL_USER_PROCESS_PARAMETERS* ProcessParameters;
    void* Reserved4[3];
    void* AtlThunkSListPtr;
    void* Reserved5;
    ULONG Reserved6;
    void* Reserved7;
    ULONG Reserved8;
    ULONG AtlThunkSListPtr32;
    void* Reserved9[45];
    BYTE  Reserved10[96];
    void* PostProcessInitRoutine;
    BYTE  Reserved11[128];
    void* Reserved12[1];
    ULONG SessionId;
    };

struct PROCESS_BASIC_INFORMATION
    {
    NTSTATUS  ExitStatus;
    PEB*      PebBaseAddress;
    KAFFINITY AffinityMask;
    KPRIORITY BasePriority;
    ULONG_PTR UniqueProcessId;
    ULONG_PTR InheritedFromUniqueProcessId;
    };

enum ADDRESS_MODE
    {
    AddrMode1616,
    AddrMode1632,
    AddrModeReal,
    AddrModeFlat
    };

struct ADDRESS64
    {
    DWORD64      Offset;
    WORD         Segment;
    ADDRESS_MODE Mode;
    };

struct KDHELP64
    {
    DWORD64 Thread;
    DWORD   ThCallbackStack;
    DWORD   ThCallbackBStore;
    DWORD   NextCallback;
    DWORD   FramePointer;
    DWORD64 KiCallUserMode;
    DWORD64 KeUserCallbackDispatcher;
    DWORD64 SystemRangeStart;
    DWORD64 KiUserExceptionDispatcher;
    DWORD64 StackBase;
    DWORD64 StackLimit;
    DWORD64 Reserved[5];
    };

struct STACKFRAME64
    {
    ADDRESS64 AddrPC;
    ADDRESS64 AddrReturn;
    ADDRESS64 AddrFrame;
    ADDRESS64 AddrStack;
    ADDRESS64 AddrBStore;
    PVOID     FuncTableEntry;
    DWORD64   Params[4];
    BOOL      Far;
    BOOL      Virtual;
    DWORD64   Reserved[3];
    KDHELP64  KdHelp;
    };

struct WOW64_FLOATING_SAVE_AREA
    {
    DWORD ControlWord;
    DWORD StatusWord;
    DWORD TagWord;
    DWORD ErrorOffset;
    DWORD ErrorSelector;
    DWORD DataOffset;
    DWORD DataSelector;
    BYTE  RegisterArea[80];
    DWORD Cr0NpxState;
    };

#pragma pack (push, 4)

struct WOW64_CONTEXT
    {
    DWORD ContextFlags;

    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;

    WOW64_FLOATING_SAVE_AREA FloatSave;

    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;

    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;

    DWORD Ebp;
    DWORD Eip;
    DWORD SegCs;
    DWORD EFlags;
    DWORD Esp;
    DWORD SegSs;

    BYTE  ExtendedRegisters[512];
    };

#pragma pack (pop)

struct SYMBOL_INFO
    {
    ULONG   SizeOfStruct;
    ULONG   TypeIndex;
    ULONG64 Reserved[2];
    ULONG   info;
    ULONG   Size;
    ULONG64 ModBase;
    ULONG   Flags;
    ULONG64 Value;
    ULONG64 Address;
    ULONG   Register;
    ULONG   Scope;
    ULONG   Tag;
    ULONG   NameLen;
    ULONG   MaxNameLen;
    CHAR    Name[1];
    };

struct IMAGEHLP_LINE64
    {
    DWORD   SizeOfStruct;
    PVOID   Key;
    DWORD   LineNumber;
    PCHAR   FileName;
    DWORD64 Address;
    };

typedef bool    (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)   (HANDLE process, DWORD64 baseAddress, void* buffer, DWORD size, DWORD* bytesRead);
typedef void*   (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64) (HANDLE process, DWORD64 baseAddress);
typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)       (HANDLE process, DWORD64 address);
typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)     (HANDLE process, HANDLE thread, ADDRESS64* address);

typedef void (*unexpected_handler)();

#pragma pack (push, 4)

struct MINIDUMP_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    };

struct MINIDUMP_THREAD_EX_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    ULONG64  BackingStoreBase;
    ULONG64  BackingStoreEnd;
    };

struct MINIDUMP_MODULE_CALLBACK
    {
    wchar_t* FullPath;
    ULONG64  BaseOfImage;
    ULONG    SizeOfImage;
    ULONG    CheckSum;
    ULONG    TimeDateStamp;
    VS_FIXEDFILEINFO VersionInfo;
    void*    CvRecord;
    ULONG    SizeOfCvRecord;
    PVOID    MiscRecord;
    ULONG    SizeOfMiscRecord;
    };

struct MINIDUMP_INCLUDE_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    };

struct MINIDUMP_INCLUDE_MODULE_CALLBACK
    {
    ULONG64  BaseOfImage;
    };

struct MINIDUMP_MEMORY_INFO
    {
    ULONG64  BaseAddress;
    ULONG64  AllocationBase;
    ULONG32  AllocationProtect;
    ULONG32  __alignment1;
    ULONG64  RegionSize;
    ULONG32  State;
    ULONG32  Protect;
    ULONG32  Type;
    ULONG32  __alignment2;
    };

struct MINIDUMP_USER_STREAM
    {
    ULONG32  Type;
    ULONG    BufferSize;
    PVOID    Buffer;
    };

struct MINIDUMP_USER_STREAM_INFORMATION
    {
    ULONG                 UserStreamCount;
    MINIDUMP_USER_STREAM* UserStreamArray;
    };

struct MINIDUMP_CALLBACK_INPUT
    {
    ULONG    ProcessId;
    HANDLE   ProcessHandle;
    ULONG    CallbackType;

    union
        {
        MINIDUMP_THREAD_CALLBACK         Thread;
        MINIDUMP_THREAD_EX_CALLBACK      ThreadEx;
        MINIDUMP_MODULE_CALLBACK         Module;
        MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
        MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
        };
    };

struct MINIDUMP_CALLBACK_OUTPUT
    {
    union
        {
        ULONG ModuleWriteFlags;
        ULONG ThreadWriteFlags;
        ULONG SecondaryFlags;

        struct
            {
            ULONG64  MemoryBase;
            ULONG    MemorySize;
            };

        struct
            {
            unsigned CheckCancel;
            unsigned Cancel;
            };

        HANDLE Handle;
        };

    struct
        {
        MINIDUMP_MEMORY_INFO VmRegion;
        unsigned             Continue;
        };

    HRESULT Status;
    };

struct MINIDUMP_EXCEPTION_INFORMATION
    {
    DWORD               ThreadId;
    EXCEPTION_POINTERS* ExceptionPointers;
    unsigned            ClientPointers;
    };

typedef int (WINAPI* MINIDUMP_CALLBACK_ROUTINE) (void* param, MINIDUMP_CALLBACK_INPUT* input, MINIDUMP_CALLBACK_OUTPUT* output);

struct MINIDUMP_CALLBACK_INFORMATION
    {
    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
    void*                     CallbackParam;
    };

enum MINIDUMP_TYPE
    {
    MiniDumpNormal                         = 0x00000000,
    MiniDumpWithDataSegs                   = 0x00000001,
    MiniDumpWithFullMemory                 = 0x00000002,
    MiniDumpWithHandleData                 = 0x00000004,
    MiniDumpFilterMemory                   = 0x00000008,
    MiniDumpScanMemory                     = 0x00000010,
    MiniDumpWithUnloadedModules            = 0x00000020,
    MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
    MiniDumpFilterModulePaths              = 0x00000080,
    MiniDumpWithProcessThreadData          = 0x00000100,
    MiniDumpWithPrivateReadWriteMemory     = 0x00000200,
    MiniDumpWithoutOptionalData            = 0x00000400,
    MiniDumpWithFullMemoryInfo             = 0x00000800,
    MiniDumpWithThreadInfo                 = 0x00001000,
    MiniDumpWithCodeSegs                   = 0x00002000,
    MiniDumpWithoutAuxiliaryState          = 0x00004000,
    MiniDumpWithFullAuxiliaryState         = 0x00008000,
    MiniDumpWithPrivateWriteCopyMemory     = 0x00010000,
    MiniDumpIgnoreInaccessibleMemory       = 0x00020000,
    MiniDumpWithTokenInformation           = 0x00040000
    };

#pragma pack (pop)

#define FOREGROUND_BLACK         ( 0                                                         )
#define FOREGROUND_CYAN          ( FOREGROUND_BLUE       | FOREGROUND_GREEN                  )
#define FOREGROUND_MAGENTA       ( FOREGROUND_BLUE       | FOREGROUND_RED                    )
#define FOREGROUND_DARKYELLOW    ( FOREGROUND_GREEN      | FOREGROUND_RED                    )
#define FOREGROUND_LIGHTGRAY     ( FOREGROUND_BLUE       | FOREGROUND_GREEN | FOREGROUND_RED )
#define FOREGROUND_DARKGRAY      (                         FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTBLUE     ( FOREGROUND_BLUE       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTGREEN    ( FOREGROUND_GREEN      | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTCYAN     ( FOREGROUND_CYAN       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTRED      ( FOREGROUND_RED        | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTMAGENTA  ( FOREGROUND_MAGENTA    | FOREGROUND_INTENSITY              )
#define FOREGROUND_YELLOW        ( FOREGROUND_DARKYELLOW | FOREGROUND_INTENSITY              )
#define FOREGROUND_WHITE         ( FOREGROUND_LIGHTGRAY  | FOREGROUND_INTENSITY              )

#define BACKGROUND_BLACK         ( 0                                                         )
#define BACKGROUND_CYAN          ( BACKGROUND_BLUE       | BACKGROUND_GREEN                  )
#define BACKGROUND_MAGENTA       ( BACKGROUND_BLUE       | BACKGROUND_RED                    )
#define BACKGROUND_DARKYELLOW    ( BACKGROUND_GREEN      | BACKGROUND_RED                    )
#define BACKGROUND_GRAY          ( BACKGROUND_BLUE       | BACKGROUND_GREEN | BACKGROUND_RED )
#define BACKGROUND_DARKGRAY      (                         BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTBLUE     ( BACKGROUND_BLUE       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTGREEN    ( BACKGROUND_GREEN      | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTCYAN     ( BACKGROUND_CYAN       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTRED      ( BACKGROUND_RED        | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTMAGENTA  ( BACKGROUND_MAGENTA    | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTYELLOW   ( BACKGROUND_DARKYELLOW | BACKGROUND_INTENSITY              )
#define BACKGROUND_WHITE         ( BACKGROUND_DARKGRAY   | BACKGROUND_INTENSITY              )

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ There are copies of MSVC compiler built-in predefined definitions, which are wrong in 64-bit mode.
//  So we have to override them. See: http://stackoverflow.com/questions/39113168
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)
                                                    //  MS ABI C++ Exception Layout
namespace Win32 {                                   //  ---------------------------
                                                    //
#pragma pack (push, 4)                              //   EXCEPTION_RECORD:
                                                    //  +==================================================+
struct ThrowInfo                                    //  |...                                               |
    {                                               //  |NumberParameters:        3, 4 or more             |
    __int32 attributes;                             //  |ExceptionInformation[0]: MS signature 0x19930520  |
    __int32 pmfnUnwind;                             //  |ExceptionInformation[1]: object* thrown           |
    __int32 pForwardCompat;                         //  |ExceptionInformation[2]: ThrowInfo* --------------+---+
    __int32 pCatchableTypeArray;                    //  |ExceptionInformation[3]: ImageBase (if params > 3)|   |
    };                                              //  +==================================================+   |
                                                    //                                                         |
struct CatchableTypeArray                           //        ThrowInfo:                                       |
    {                                               //        +======================================+ <-------+
    __int32 nCatchableTypes;                        //        |   ...                                |
    __int32 arrayOfCatchableTypes[];                //  +-----+-- pCatchableTypeArray (ptr/RVA)      |
    };                                              //  |     +======================================+
                                                    //  |
struct CatchableType                                //  |     CatchableTypeArray:
    {                                               //  +---> +======================================+
    __int32 properties;                             //        |   ...                                |
    __int32 pType;                                  //  +-----+-- arrayOfCatchableTypes[0] (ptr/RVA) |
    __int32 thisDisplacement[3]; // struct _PMD     //  |     +======================================+
    __int32 sizeOrOffset;                           //  |
    __int32 copyFunction;                           //  |     CatchableType:
    };                                              //  +---> +====================+
                                                    //        | ...                |        std::type_info:
#pragma pack (pop)                                  //        | pType (ptr/RVA) ---+------> +==================+
                                                    //        | ...                |        |type_info data    |
} // namespace Win32                                //        +====================+        |...               |
                                                    //                                      +==================+
#endif

// Similar to __CxxDetectRethrow(), see C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\crtsrc\vcruntime\frame.cpp:

#define _TX_MSC__CXX_DETECT_RETHROW( exc )                                     \
    (                                                                          \
    (exc)                                          &&                          \
    (exc) -> ExceptionCode    == EXCEPTION_CPP_MSC &&                          \
    (exc) -> NumberParameters >= 3                 &&                          \
                                                                               \
    ((exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3) && \
                                                                               \
    (exc) -> ExceptionInformation[2] == 0                                      \
    )

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ The corresponding structures for GCC
//
//  From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/unwind-cxx.h
//  See:  http://mentorembedded.github.io/cxx-abi/abi-eh.html#cxx-abi
//-----------------------------------------------------------------------------------------------------------------

#if defined (_GCC_VER)
                                                    // GCC ABI C++ Exception layout. A/B are ExceptionInformation[0].
namespace ABI {                                     // --------------------------------------------------------------
                                                    //
struct __cxa_exception                              // Case A: "_Unwind_Exception* A" is undependent exception:
    {                                               // --------------------------------------------------------
    union {                                         //
        struct                                      //           __cxa_exception:           std::type_info:
            {                                       //       -*--+====================+     +==================+
            ::std::type_info* exceptionType;        //        ^  |exceptionType* -----+---->|type_info data    |
            void (*exceptionDestructor)(void*);     //        |  |...                 |     |...               |
            };                                      //       -1  |                    |     +==================+
        struct                                      //        |  |                    |
            {                                       // A >----|--+--------------------+
            __cxa_exception*  primaryException;     //     |  |  |unwindHeader        |
            void (*padding)();                      //    +1  |  |                    |
            };                                      //     |  |  |                    |
        };                                          //     V  |  |                    |
                                                    //    -*---  +====================+
    std::unexpected_handler   unexpectedHandler;    //           |object              |
    std::terminate_handler    terminateHandler;     //           +--------------------+
                                                    //
    __cxa_exception*          nextException;        // Case B: "_Unwind_Exception* B" is dependent exception
    int                       handlerCount;         // (unwindHeader.exception_class & 1 != 0):
    int                       handlerSwitchValue;   // -----------------------------------------------------
    const unsigned char*      actionRecord;         //
    const unsigned char*      languageSpecificData; //           __cxa_exception:               __cxa_exception:
    void*                     catchTemp;            //       -*--+====================+     -*--+=================+
    void*                     adjustedPtr;          //        ^  |primaryException* --+--    ^  |exceptionType*   |
                                                    //        |  |...                 |  \   |  |...              |
    _Unwind_Exception         unwindHeader;         //       -1  |                    |  |   |  |                 |
    };                                              //        |  |                    |  |   |  |                 |
                                                    // B >----|--+--------------------+  |  -1  +-----------------+
struct __cxa_eh_globals                             //     |  |  |unwindHeader        |  |   |  |unwindHeader     |
    {                                               //    +1  |  |                    |  |   |  |                 |
    __cxa_exception* caughtExceptions;              //     |  |  |                    |  |   |  |                 |
    unsigned int     uncaughtExceptions;            //     V  |  |                    |  \   |  |                 |
    };                                              //    -*---  +====================+   -->*--+=================+
                                                    //           |...                 |         |object           |
} // namespace ABI                                  //           .                    .         |                 |
                                                    //                                          +-----------------+

extern "C" ABI::__cxa_eh_globals* __cxa_get_globals();

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ Hand-made IAT.
//  Some IDEs don't link with these libs by default in console projects, so do sunrise by hand. :(
//-----------------------------------------------------------------------------------------------------------------

// Hand-made DLLIMPORT helpers

#define _TX_DLLIMPORT(     lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, true)

#define _TX_DLLIMPORT_OPT( lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, false)

#define _TX_DLLIMPORT_CRT( lib, retval, name, params ) \
     retval (      * name) params = (retval (      *) params) _txDllImport (lib ".dll", #name, false)

typedef void (*_tx_FARPROC)();

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required = true);

//-----------------------------------------------------------------------------------------------------------------

namespace Win32 {

_TX_DLLIMPORT     ("GDI32",    HDC,      CreateCompatibleDC,            (HDC dc));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateCompatibleBitmap,        (HDC dc, int width, int height));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetStockObject,                (int object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  SelectObject,                  (HDC dc, HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetCurrentObject,              (HDC dc, unsigned objectType));
_TX_DLLIMPORT     ("GDI32",    int,      GetObjectA,                    (HGDIOBJ obj, int bufsize, void* buffer));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GetObjectType,                 (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteDC,                      (HDC dc));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteObject,                  (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetTextColor,                  (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetBkColor,                    (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    int,      SetBkMode,                     (HDC dc, int bkMode));
_TX_DLLIMPORT     ("GDI32",    HFONT,    CreateFontA,                   (int height, int width, int escapement, int orientation,
                                                                         int weight, DWORD italic, DWORD underline, DWORD strikeout,
                                                                         DWORD charSet, DWORD outputPrec, DWORD clipPrec,
                                                                         DWORD quality, DWORD pitchAndFamily, const char face[]));
_TX_DLLIMPORT     ("GDI32",    int,      EnumFontFamiliesExA,           (HDC dc, LPLOGFONT logFont, FONTENUMPROC enumProc,
                                                                         LPARAM lParam, DWORD reserved));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetPixel,                      (HDC dc, int x, int y, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, GetPixel,                      (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    HPEN,     CreatePen,                     (int penStyle, int width, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    HBRUSH,   CreateSolidBrush,              (COLORREF color));
_TX_DLLIMPORT     ("GDI32",    bool,     MoveToEx,                      (HDC dc, int x, int y, POINT* point));
_TX_DLLIMPORT     ("GDI32",    bool,     LineTo,                        (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    bool,     Polygon,                       (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Polyline,                      (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     PolyBezier,                    (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Rectangle,                     (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     RoundRect,                     (HDC dc, int x0, int y0, int x1, int y1, int sizeX, int sizeY));
_TX_DLLIMPORT     ("GDI32",    bool,     Ellipse,                       (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     Arc,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Pie,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Chord,                         (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     TextOutA,                      (HDC dc, int x, int y, const char string[], int length));
_TX_DLLIMPORT     ("GDI32",    UINT,     SetTextAlign,                  (HDC dc, unsigned mode));
_TX_DLLIMPORT     ("GDI32",    bool,     GetTextExtentPoint32A,         (HDC dc, const char string[], int length, SIZE* size));
_TX_DLLIMPORT     ("GDI32",    bool,     ExtFloodFill,                  (HDC dc, int x, int y, COLORREF color, unsigned type));
_TX_DLLIMPORT     ("GDI32",    bool,     BitBlt,                        (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src,  int xSrc,  int ySrc,  DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     StretchBlt,                    (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src, int xSrc, int ySrc, int wSrc, int hSrc, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     PlgBlt,                        (HDC dest, const POINT* parallelogram,
                                                                         HDC src, int xSrc, int ySrc, int width, int height,
                                                                         HBITMAP mask, int xMask, int yMask));
_TX_DLLIMPORT     ("GDI32",    int,      SetDIBitsToDevice,             (HDC dc, int xDest, int yDest, DWORD width, DWORD height,
                                                                         int xSrc, int ySrc, unsigned startLine, unsigned numLines,
                                                                         const void* data, const BITMAPINFO* info, unsigned colorUse));
_TX_DLLIMPORT     ("GDI32",    int,      GetDIBits,                     (HDC hdc, HBITMAP hbmp, unsigned uStartScan, unsigned cScanLines,
                                                                         void* lpvBits, BITMAPINFO* lpbi, unsigned usage));
_TX_DLLIMPORT     ("GDI32",    bool,     PatBlt,                        (HDC dc, int x0, int y0, int width, int height, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    int,      SetROP2,                       (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    int,      SetStretchBltMode,             (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GdiSetBatchLimit,              (DWORD limit));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateDIBSection,              (HDC dc, const BITMAPINFO* bmInfo, unsigned colorUsage, void **vBits,
                                                                         HANDLE section, DWORD offset));

_TX_DLLIMPORT     ("User32",   int,      DrawTextA,                     (HDC dc, const char text[], int length, RECT* rect, unsigned format));
_TX_DLLIMPORT     ("User32",   HANDLE,   LoadImageA,                    (HINSTANCE inst, const char name[], unsigned type,
                                                                        int sizex, int sizey, unsigned mode));
_TX_DLLIMPORT_OPT ("User32",   bool,     IsHungAppWindow,               (HWND wnd));
_TX_DLLIMPORT_OPT ("User32",   HWND,     GhostWindowFromHungWindow,     (HWND wnd));

_TX_DLLIMPORT     ("WinMM",    bool,     PlaySound,                     (const char sound[], HMODULE mod, DWORD mode));

_TX_DLLIMPORT_OPT ("MSImg32",  bool,     TransparentBlt,                (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         unsigned transparentColor));
_TX_DLLIMPORT_OPT ("MSImg32",  bool,     AlphaBlend,                    (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         BLENDFUNCTION blending));

_TX_DLLIMPORT     ("Kernel32", void,     ExitProcess,                   (unsigned retcode));
_TX_DLLIMPORT     ("Kernel32", bool,     TerminateProcess,              (HANDLE process, unsigned retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalExit,                     (int retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalAppExitA,                 (unsigned action, const char message[]));
_TX_DLLIMPORT     ("Kernel32", HWND,     GetConsoleWindow,              (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetConsoleFont,                (HANDLE con, DWORD fontIndex));
_TX_DLLIMPORT_OPT ("Kernel32", DWORD,    GetNumberOfConsoleFonts,       (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFont,         (HANDLE con, bool maxWnd, CONSOLE_FONT_INFO*   curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", void,     RtlCaptureContext,             (CONTEXT* contextRecord));
_TX_DLLIMPORT_OPT ("Kernel32", USHORT,   RtlCaptureStackBackTrace,      (DWORD framesToSkip, DWORD framesToCapture, void** backTrace, DWORD* hash));
_TX_DLLIMPORT_OPT ("Kernel32", void*,    AddVectoredExceptionHandler,   (unsigned long firstHandler, PVECTORED_EXCEPTION_HANDLER handler));
_TX_DLLIMPORT_OPT ("Kernel32", unsigned, RemoveVectoredExceptionHandler,(void* handler));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetModuleHandleEx,             (DWORD flags, const char moduleName[], HMODULE* module));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     IsWow64Process,                (HANDLE process, int* isWow64Process));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     Wow64GetThreadContext,         (HANDLE thread, WOW64_CONTEXT* context));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetThreadStackGuarantee,       (unsigned long* stackSize));

_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoInitialize,                  (void*));
_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoCreateInstance,              (REFCLSID clsId, IUnknown*, DWORD, REFIID iId, PVOID* value));
_TX_DLLIMPORT     ("OLE32",    void,     CoUninitialize,                (void));

_TX_DLLIMPORT     ("Shell32",  HINSTANCE,ShellExecuteA,                 (HWND wnd, const char operation[], const char file[],
                                                                         const char parameters[], const char directory[], int showCmd));

_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIA,                      (const char    string[], const char    search[]));
_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIW,                      (const wchar_t string[], const wchar_t search[]));

_TX_DLLIMPORT_OPT ("NTDLL",    char*,    wine_get_version,              (void));
_TX_DLLIMPORT     ("NTDLL",    NTSTATUS, NtQueryInformationProcess,     (HANDLE process, int infoClass,
                                                                         void* processInfo, unsigned long szProcessInfo, unsigned long* szReturnInfo));

_TX_DLLIMPORT_CRT ("MSVCRT",   void,     exit,                          (int retcode));
_TX_DLLIMPORT_CRT ("MSVCRT",   void,     _cexit,                        (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _fpreset,                      (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _controlfp,                    (unsigned control, unsigned mask));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthread,                  (void (__cdecl* start_address) (void*), unsigned stack_size, void* arglist));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthreadex,                (void* security, unsigned stack_size, unsigned (__stdcall* start_address) (void*),
                                                                         void *arglist, unsigned init_flag, unsigned* thread_addr));
_TX_DLLIMPORT_CRT ("MSVCRT",   char*,    __unDName,                     (char* outStr, const char* mangledName, int outStrLen,
                                                                         void* (*mallocFunc) (size_t size), void (*freeFunc) (void *pointer),
                                                                         unsigned short flags));
_TX_DLLIMPORT_CRT ("MSVCRT",   unexpected_handler, set_unexpected,      (unexpected_handler handler));

_TX_DLLIMPORT_OPT ("OpenGL32", HDC,         wglGetCurrentDC,            (void));
_TX_DLLIMPORT_OPT ("OpenGL32", unsigned,    glGetError,                 (void));
_TX_DLLIMPORT_OPT ("Glu32",    const char*, gluErrorString,             (unsigned error));

_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     MiniDumpWriteDump,             (HANDLE process, DWORD processId, HANDLE file, MINIDUMP_TYPE dumpType,
                                                                         MINIDUMP_EXCEPTION_INFORMATION*   exceptionParam,
                                                                         MINIDUMP_USER_STREAM_INFORMATION* userStreamParam,
                                                                         MINIDUMP_CALLBACK_INFORMATION*    callbackParam));

_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("DbgHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
namespace MinGW {
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("MgwHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
} // namespace MinGW

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal function prototypes, macros and constants
//  @name    Ïðîòîòèïû âíóòðåííèõ ôóíêöèé, ìàêðîñû è êîíñòàíòû
//=================================================================================================================
//! @{

const int        _TX_IDM_ABOUT                            =   40000,       // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
                 _TX_IDM_CONSOLE                          =   40001,
                 _TX_WM_CREATEWND                         =   0x7FF0,      // Ñîîáùåíèÿ äëÿ ñîçäàíèÿ/óíè÷òîæåíèÿ
                 _TX_WM_DESTROYWND                        =   0x7FF1;      // îêîí â ïîòîêå Canvas

//-----------------------------------------------------------------------------------------------------------------

int              _txInitialize();
void             _txCleanup();

HWND             _txCanvas_CreateWindow      (const SIZE* size);
inline bool      _txCanvas_OK() tx_nodiscard;

bool             _txCanvas_OnCREATE          (HWND wnd);
bool             _txCanvas_OnDESTROY         (HWND wnd);
bool             _txCanvas_OnCLOSE           (HWND);
bool             _txCanvas_OnPAINT           (HWND wnd);
bool             _txCanvas_OnKEYDOWN         (HWND wnd, WPARAM vk, LPARAM info);
bool             _txCanvas_OnCHAR            (HWND wnd, WPARAM ch, LPARAM info);
bool             _txCanvas_OnTIMER           (HWND wnd, WPARAM id);
bool             _txCanvas_OnMOUSEMOVE       (HWND wnd, WPARAM buttons, LPARAM coords);
bool             _txCanvas_OnMOUSELEAVE      (HWND wnd);
bool             _txCanvas_OnCREATEWND       (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnDESTROYWND      (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnCmdCONSOLE      (HWND wnd, WPARAM cmd);
bool             _txCanvas_OnCmdABOUT        (HWND wnd, WPARAM cmd);

unsigned WINAPI  _txCanvas_ThreadProc        (void* data);
LRESULT CALLBACK _txCanvas_WndProc           (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);

int              _txCanvas_SetRefreshLock    (int count);

HDC              _txBuffer_Create            (HWND wnd = NULL, const POINT* size = NULL, HBITMAP bitmap = NULL,
                                              RGBQUAD** pixels = NULL) tx_nodiscard;
bool             _txBuffer_Delete            (HDC* dc);
bool             _txBuffer_Select            (HGDIOBJ obj, HDC dc = txDC());

HWND             _txConsole_Attach();
bool             _txConsole_OK() tx_nodiscard;
bool             _txConsole_Detach           (bool activate);
bool             _txConsole_Draw             (HDC dc);
bool             _txConsole_SetUnicodeFont();

const char*       txRegisterClass            (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra);
HWND              txCreateExtraWindow        (CREATESTRUCT createData);
HICON            _txCreateTXIcon             (int size) tx_nodiscard;
int              _txSetFinishedText          (HWND wnd);
void             _txPauseBeforeTermination   (HWND canvas);
int              _txIsParentWaitable         (DWORD* parentPID = NULL) tx_nodiscard;
int              _txGetInput();

LRESULT CALLBACK _txPlayVideo_WndProc        (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
const char*      _txPlayVideo_FindVLC() tx_nodiscard;

bool             _txCreateShortcut           (const char shortcutName[],
                                              const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
                                              const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
                                              const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
                                              COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));

void*            _tx_DLGTEMPLATE_Create      (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                                              WORD controls, short x, short y, short cx, short cy,
                                              const char caption[], const char font[], WORD fontsize,
                                              const char menu[]) tx_nodiscard;

void*            _tx_DLGTEMPLATE_Add         (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                                              short x, short y, short cx, short cy,
                                              WORD id, const char wclass[], const char caption[]);

const char*      _txError                    (const char file[] = NULL, int line = 0, const char func[] = NULL, unsigned color = 0,
                                              const char msg[] = NULL, ...) tx_printfy (5);
const char*      _txProcessError             (const char file[], int line, const char func[], unsigned color,
                                              const char msg[], va_list args);
void             _txOnTerminate();
void             _txOnUnexpected();
void             _txOnPureCall();
void             _txOnNewHandlerAnsi();
int              _txOnNewHandler             (size_t size);
void             _txOnSignal                 (int signal = 0, int fpe = 0);
BOOL WINAPI      _txOnConsoleCtrlEvent       (DWORD type);
void             _txOnSecurityError          (int code, void*);
void             _txOnSecurityErrorAnsi      (const char* msg, void* ptr, int code);
int              _txOnMatherr                (_exception* except);
void             _txOnInvalidParam           (const wchar_t* expr, const wchar_t* func, const wchar_t* file,
                                              unsigned line, uintptr_t);
int              _txOnAllocHook              (int type, void* data, size_t size, int use, long request,
                                              const unsigned char* file, int line);
int              _txOnRTCFailure             (int type, const char* file, int line, const char* module, const char* format, ...) tx_printfy (5);
int              _txOnErrorReport            (int type, const char* text, int* ret);
int               tx_glGetError              (int setError = INT_MIN);

void             _txOnCExit();
void             _txOnExit                   (int      retcode);
void             _txOnFatalExit              (int      retcode);
void             _txOnExitProcess            (unsigned retcode);
void             _txOnFatalAppExitA          (unsigned action, const char message[]);
bool             _txOnTerminateProcess       (HANDLE process, unsigned retcode);
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
                 _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter);
void             _txWatchdogTerminator       (void* timeout);  // Only Arnold-type series are supported, not T1000

long WINAPI      _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc);
long WINAPI      _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc);
long             _txOnExceptionSEH           (EXCEPTION_POINTERS* exc, const char func[]);
intptr_t         _txDumpExceptionSEH         (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[]);
intptr_t         _txDumpExceptionObj         (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type);
intptr_t         _txDumpExceptionCPP         (char what[], intptr_t size, unsigned code = 0,
                                              unsigned params = 0, const ULONG_PTR info[] = NULL);

void             _txStackBackTrace           (const char file[] = "?", int line = 0, const char func[] = "?",
                                              bool readSource = true);
const char*      _txCaptureStackBackTrace    (int framesToSkip = 0, bool readSource = true,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
int              _txStackWalk                (int framesToSkip, size_t szCapture, void* capture[], unsigned long* backTraceHash,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
const char*      _txCaptureStackBackTraceTX  (int framesToSkip = 0, bool readSource = false);

const char*      _txSymPrintFromAddr         (void* addr = NULL, const char format[] = NULL, ...) tx_printfy (2);
bool             _txSymGetFromAddr           (void* addr, Win32::SYMBOL_INFO** symbol = NULL,
                                              Win32::IMAGEHLP_LINE64** line = NULL, const char** module = NULL,
                                              const char** source = NULL, int context = 2);
intptr_t         _txReadSource               (char buf[], intptr_t size, const char file[],
                                              int linStart = 0, int linEnd = INT_MIN, int linMark = INT_MIN);
bool             _txCreateMiniDump           (EXCEPTION_POINTERS* exc);

uintptr_t        _txSetProcAddress           (const char funcName[], uintptr_t newFunc, const char dllName[] = NULL,
                                              int useHotPatching = false, HMODULE module = NULL, bool debug = false);
bool             _txInDll() tx_nodiscard;
PROCESSENTRY32*  _txFindProcess              (unsigned pid = GetCurrentProcessId()) tx_nodiscard;
bool             _txKillProcess              (DWORD pid);
bool             _txIsBadReadPtr             (const void* address);
bool             _txCheckSourceCP            (int needCP = _TX_CODEPAGE, bool verbose = true);
bool             _txGetCommandLine           (wchar_t cmdLine[], size_t szCmdLine, unsigned pid = _getpid());
IMAGE_NT_HEADERS*_txGetNtHeaders             (HMODULE module = GetModuleHandle (NULL)) tx_nodiscard;
const char*      _txAppInfo() tx_nodiscard;

intptr_t         _tx_snprintf_s              (char stream[], intptr_t size, const char format[], ...) tx_printfy (3);
intptr_t         _tx_vsnprintf_s             (char stream[], intptr_t size, const char format[], va_list arg);
void              txReopenStdio();

#if defined (_CLANG_VER) && !defined (_MSC_VER)
void             _txLibCppDebugFunction      (std::__libcpp_debug_info const& info);
#endif

#if defined (__CYGWIN__)

int              _getch();
int              _putch (int ch);
int              _kbhit() tx_nodiscard;

#endif

//-----------------------------------------------------------------------------------------------------------------
// There are macros for __FILE__ and __LINE__ to work properly.

#if !defined (NDEBUG)

    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) && \
                                                     (assert (cond), true) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå."), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("Ïàðàìåòð \"%s\" íåâåðåí. Âîçìîæíî, ýòîò õîëñò íå ñîçäàí, " \
                                                                "èëè óæå óíè÷òîæåí, èëè íå çàãðóçèëàñü êàðòèíêà.", #dc), 1) )
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( (!(dc) &&                                           \
                                                     _TX_TXWINDOW_FAILED()) || _TX_HDC_FAILED (dc) )

#else
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define _TX_DEFAULT_HDC_FAILED(dc)         ( !(dc) &&                                            \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
#endif

//-----------------------------------------------------------------------------------------------------------------
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but MSVC rejects it. So sad. :'(

#if !defined (NDEBUG)
    #define  _TX_ON_DEBUG( code )              { code; }
#else
    #define  _TX_ON_DEBUG( code )              ;
#endif

//-----------------------------------------------------------------------------------------------------------------
// Invokes an error without location information. "$$" restores TX-related call location context

#define _TX_UNEXPECTED( ... )                  $$ _txError (NULL, 0, NULL, 0, ##__VA_ARGS__)

//-----------------------------------------------------------------------------------------------------------------
// Safe call of a function via its pointer

#define _TX_CALL(  func, param )               ( (func)? ((func) param) :       0 )
#define _TX_CALLv( func, param )               ( (func)? ((func) param) : (void)0 )

//-----------------------------------------------------------------------------------------------------------------
// This is a macro because cond is an expression and is not always a function. Lack of lambdas in pre-C++0x.

#define      _txWaitFor( cond, time )          { for (DWORD _t = GetTickCount() + (time); \
                                                      !(cond) && GetTickCount() < _t;     \
                                                      Sleep (_txWindowUpdateInterval)) ;  \
                                                 if  (!(cond))                            \
                                                      _txTrace (__FILE__, __LINE__, NULL, "WARNING: Timeout: " #cond "."); }
//-----------------------------------------------------------------------------------------------------------------
// Detouring in case of SEH mechanism

#define _txSetJmp()                            ( setjmp (_txDumpExceptionObjJmp) == 0 )

#define _txClearJmp()                          { *(unsigned long long*) _txDumpExceptionObjJmp = 0; }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal global data
//! @name    Âíóòðåííèå ãëîáàëüíûå äàííûå
//
//           Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
//           Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåð, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
//           Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
//           Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé, èëè êëàññ.
//=================================================================================================================
//! @{

int                          _txInitialized              = _TX_NOINIT || _txInitialize();

volatile const unsigned      _txCanaryFirst              = 0x776F656D; // A very system value

volatile unsigned            _txMainThreadId             = 0;          // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
volatile HANDLE              _txMainThread               = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà

volatile unsigned            _txCanvas_ThreadId          = 0;          // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
volatile HANDLE              _txCanvas_Thread            = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
volatile HWND                _txCanvas_Window            = NULL;       // Äåñêðèïòîð îêíà õîëñòà TXLib

HDC                          _txCanvas_BackBuf[2]        = {NULL,      // [0] Main TXLib in-memory DC, where user's pictures lies
                                                            NULL};     // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()

RGBQUAD*                     _txCanvas_Pixels            = NULL;       // Memory buffer of _txCanvas_BackBuf[0]

HBITMAP                      _txStockBitmap              = NULL;       // Equivalent of GetStockObject (BITMAP),
                                                                       // see https://devblogs.microsoft.com/oldnewthing/20100416-00/?p=14313

CRITICAL_SECTION             _txCanvas_LockBackBuf       = {0,-1};     // Prevent simultaneous access to back buffer, see txLock()

UINT_PTR                     _txCanvas_RefreshTimer      = 1;          // Timer ID to redraw TXLib window
volatile int                 _txCanvas_RefreshLock       = 0;          // Blocks auto on-timer canvas update, see txBegin/txEnd

::std::vector<HDC>*          _txCanvas_UserDCs           = NULL;       // List of DCs allocated, for auto-free

volatile bool                _txConsole_IsBlinking       = true;       // To blink or not to blink, that is the question.

bool                         _txConsole                  = false;      // Only first TXLib module in app can own the console
bool                         _txMain                     = false;      // First TXLib wnd opened (closing it terminates program)
bool                         _txIsDll                    = false;      // TXLib module is in DLL
volatile bool                _txRunning                  = false;      // main() is still running
volatile bool                _txExit                     = false;      // exit() is active

volatile POINT               _txMousePos                 = {-1,-1};    // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
volatile unsigned            _txMouseButtons             = 0;

volatile WNDPROC             _txAltWndProc               = NULL;       // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().

_tx_thread _txLoc            _txLoc::Cur                 = {};         // Execution point tracking and trace state, see "$" macro

volatile int                 _txErrors                   = 0;          // TX_ERROR calls sequental number
int                          _txOGLError                 = 0;          // Last OpenGL error when using tx_glGetError()
volatile long                _txSENumber                 = 0;          // SEH exceptions sequental number
volatile long                _txSEFatalNumber            = 0;          // SEH fatal exceptions sequental number
char                         _txDumpSE [_TX_BUFSIZE]     = "";         // SEH dump data area
char                         _txTraceSE[_TX_HUGEBUFSIZE] = "";         // Stack trace data area

LPTOP_LEVEL_EXCEPTION_FILTER _txPrevUEFilter             = NULL;       // Previous UnhandledExceptionFilter

jmp_buf                      _txDumpExceptionObjJmp      = {};         // Hook for _txDumpExceptionObj

const volatile uintptr_t     _txForceImport[]            = { (uintptr_t) ::TerminateProcess,              (uintptr_t) ::ExitProcess,
                                                             (uintptr_t) ::FatalExit,                     (uintptr_t) ::FatalAppExitA,
                                                             (uintptr_t) ::exit,                          (uintptr_t) Win32::_controlfp,
                                                             (uintptr_t) Win32::Polyline,                 (uintptr_t) Win32::PolyBezier,
                                                             (uintptr_t) Win32::RoundRect,                (uintptr_t) Win32::RemoveVectoredExceptionHandler,
                                                             (uintptr_t) Win32::PlgBlt,                   (uintptr_t) Win32::RtlCaptureStackBackTrace,
                                                             (uintptr_t) Win32::SymInitialize,            (uintptr_t) Win32::MinGW::SymInitialize,
                                                             (uintptr_t) Win32::SymSetOptions,            (uintptr_t) Win32::MinGW::SymSetOptions,
                                                             (uintptr_t) Win32::SymGetLineFromAddr64,     (uintptr_t) Win32::MinGW::SymGetLineFromAddr64,
                                                             (uintptr_t) Win32::SymFromAddr,              (uintptr_t) Win32::MinGW::SymFromAddr,
                                                             (uintptr_t) Win32::SymCleanup,               (uintptr_t) Win32::MinGW::SymCleanup,
                                                             (uintptr_t) Win32::SymGetModuleBase64,       (uintptr_t) Win32::MinGW::SymGetModuleBase64,
                                                             (uintptr_t) Win32::SymFunctionTableAccess64, (uintptr_t) Win32::MinGW::SymFunctionTableAccess64,
                                                             (uintptr_t) Win32::StackWalk64,              (uintptr_t) Win32::MinGW::StackWalk64,
                                                             (uintptr_t) Win32::StrStrIA,                 (uintptr_t) Win32::Wow64GetThreadContext };

volatile const unsigned      _txCanaryLast               = 0x5E2E2E5E; // Another very system value

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib engine init/check/cleanup
//! @name    Èíèöèàëèçàöèÿ/ïðîâåðêà/çàâåðøåíèå TXLib
//=================================================================================================================
//! @{

//-----------------------------------------------------------------------------------------------------------------
//{          Early initialization
//-----------------------------------------------------------------------------------------------------------------

int _txInitialize()
    {
    if (_txInitialized) return 1;
    _txInitialized = 1;

    #if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)  // See http://msdn.microsoft.com/en-us/library/w2fhc9a3%28v=vs.90%29.aspx
    _CrtSetBreakAlloc (_TX_ALLOC_BREAK);                 // and http://support.microsoft.com/ru-ru/kb/151585
    #endif

    #if defined (_TX_ALLOW_TRACE)
    _txLocLvlSet (1);
    #endif

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
                                     "compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

    _txMainThreadId = GetCurrentThreadId();
    _txMainThread   = OpenThread (THREAD_ALL_ACCESS, false, _txMainThreadId);

$3  _txIsDll = _txInDll();

$   if (!_txIsDll)
        {
$       _txConsole = ! FindAtom ("_txConsole");
$       (void)          AddAtom ("_txConsole");
        }

$   if (_txConsole)
        {
$       _txCheckSourceCP (_TX_CODEPAGE, true);

$       unsigned long stackSize = _TX_STACKSIZE;
$       _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$       _txOnSignal();

$       if (!*_txLogName)
            {$ _tx_snprintf_s (_txLogName, sizeof (_txLogName) - 1, "%s.log", txGetModuleFileName()); }

$       if (!_txIsDll)
            {
$           _TX_CALL  (Win32::AddVectoredExceptionHandler, (1, (PVECTORED_EXCEPTION_HANDLER)  _txVectoredExceptionHandler));
$           _txPrevUEFilter = SetUnhandledExceptionFilter  (   (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter);
            }

$       ::std::set_terminate             (_txOnTerminate);
$       ::std::set_new_handler           (_txOnNewHandlerAnsi);
$       _TX_CALL (Win32::set_unexpected, (_txOnUnexpected));

        #if defined (_CLANG_VER) && !defined (_MSC_VER)
$       ::std::__libcpp_debug_function = _txLibCppDebugFunction;
        #endif

$       SetConsoleCtrlHandler (_txOnConsoleCtrlEvent, true);

$       SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);

        #if defined (_MSC_VER)

$       _set_printf_count_output (1);

$       _set_new_handler (_txOnNewHandler);
$       _set_new_mode (1);

        #if !defined (_CLANG_VER)

$       _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$       _CrtSetAllocHook (_txOnAllocHook);

$       unsigned mode = _CRTDBG_MODE_FILE;
$       if (_CrtSetReportHook2 (_CRT_RPTHOOK_INSTALL, (_CRT_REPORT_HOOK) _txOnErrorReport) > 0) mode = 0;

$       _CrtSetReportMode (_CRT_WARN,   _CRTDBG_MODE_DEBUG | mode);
$       _CrtSetReportMode (_CRT_ERROR,  _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportFile (_CRT_WARN,   _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ERROR,  _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);

        #endif

$       _set_abort_behavior (_WRITE_ABORT_MSG, _WRITE_ABORT_MSG);
$       _set_abort_behavior (0,                _CALL_REPORTFAULT);

$       _RTC_SetErrorFunc              (_txOnRTCFailure);
$       _set_purecall_handler          (_txOnPureCall);
$       _set_invalid_parameter_handler (_txOnInvalidParam);

        #endif

        #if defined (__STDC_LIB_EXT1__)
$       ::std::set_constraint_handler_s (_txOnSecurityErrorAnsi);
        #endif

        #if !defined (__CYGWIN__) && defined (_GCC_VER) && (_GCC_VER >= 530) && !defined (i386)
$       __setusermatherr (_txOnMatherr);
        #endif

        #if !defined (__CYGWIN__)
$       _set_error_mode (_OUT_TO_MSGBOX | _OUT_TO_STDERR);
        #endif

$       HWND console = _txConsole_Attach();
$       SetWindowTextA (console, txGetModuleFileName (false));
        }

$   InitializeCriticalSection (&_txCanvas_LockBackBuf);

$   _txSetProcAddress ("ExitProcess",                 (uintptr_t) _txOnExitProcess,                 "KERNEL32.DLL");
$   _txSetProcAddress ("TerminateProcess",            (uintptr_t) _txOnTerminateProcess,            "KERNEL32.DLL");
$   _txSetProcAddress ("FatalExit",                   (uintptr_t) _txOnFatalExit,                   "KERNEL32.DLL");
$   _txSetProcAddress ("FatalAppExitA",               (uintptr_t) _txOnFatalAppExitA,               "KERNEL32.DLL");
$   _txSetProcAddress ("UnhandledExceptionFilter",    (uintptr_t) _txUnhandledExceptionFilter,      "KERNEL32.DLL", true);
$   _txSetProcAddress ("SetUnhandledExceptionFilter", (uintptr_t) _txOnSetUnhandledExceptionFilter, "KERNEL32.DLL");
$   _txSetProcAddress ("exit",                        (uintptr_t) _txOnExit);
$   _txSetProcAddress ("_cexit",                      (uintptr_t) _txOnCExit);

$   atexit (_txCleanup);

$   if (_txConsole)
        {
$       txSetConsoleAttr (FOREGROUND_LIGHTGRAY);

$       tx_fpreset();

$       srand ((unsigned) time (NULL));

$       SetLastError (0);
$       errno = 0;

        #if !defined (__CYGWIN__)
$       _doserrno = 0;
        #endif
        }

$   HDC dc = Win32::CreateCompatibleDC (NULL); dc asserted;
$   _txStockBitmap = (HBITMAP) Win32::SelectObject (dc, Win32::CreateCompatibleBitmap (dc, 1, 1)); _txStockBitmap asserted;
$   Win32::DeleteObject (Win32::SelectObject (dc, _txStockBitmap)) asserted;
$   Win32::DeleteDC (dc) asserted;

$   return 1;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCheckSourceCP (int needCP /*= _TX_CODEPAGE*/, bool verbose /*= true*/)
    {
$3  const char* sCodePage = NULL;
$   int codePage = 0;

$   switch (((unsigned const char*) "À") [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }

$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please

$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }

$   return (codePage == needCP);
    }

//-----------------------------------------------------------------------------------------------------------------

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;

    static char dllPaths [2][MAX_PATH] = {"", ""};

    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";

        // dllPaths[0] is relative to the TX Setup directory stored in the Registry

        char* path = dllPaths[0];

        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);

        // dllPaths[1] is relative to TXib.h file used in compilation

        path = dllPaths[1];

        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }

        if (char* dir = strrchr (path, '\\')) *dir = 0;

        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }

    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);

    if (arch)
        {
        assert (arch >= dllFileName);

        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));

        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }

    HMODULE   dll = GetModuleHandle (dllFileName);

    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);

    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);

        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);

        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }

    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);

    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;

    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);

    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè
#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
    // ïîñòðîåíà ìàêðîñàìè TX_BEGIN_MESSAGE_MAP è äðóãèìè). Ìîæíî íå äåëàòü âíóòðåííåãî êëàññà, íî òîãäà îêîííóþ
    // ôóíêöèþ ïðèäåòñÿ ïèñàòü â ãëîáàëüíîé îáëàñòè âèäèìîñòè, è str îáúÿâëÿòü ãëîáàëüíî òîæå (èëè ïåðåäàâàòü åå
    // àäðåñ ÷åðåç DialogBoxParam è çàïèñûâàòü åãî â êëàññ âî âðåìÿ îáðàáîòêè WM_INITDIALOG).
    //-------------------------------------------------------------------------------------------------------------
    struct inputDlg : txDialog
        {
        char str [1024];
 
        //---------------------------------------------------------------------------------------------------------
 
        inputDlg() :
            str()
            {}
 
        //---------------------------------------------------------------------------------------------------------
 
        TX_BEGIN_MESSAGE_MAP()    // Êàðòà ñîîáùåíèé (íà ñàìîì äåëå ýòî íà÷àëî îêîííîé ôóíêöèè).
 
            TX_COMMAND_MAP        // Çäåñü îáðàáàòûâàþòñÿ WM_COMMAND (íà ñàìîì äåëå ýòî îïåðàòîð switch).
 
                //-------------------------------------------------------------------------------------------------
                // Ïðè íàæàòèè êíîïêè OK êîïèðóåì ñòðîêó èç ïîëÿ ââîäà â íàøó ïåðåìåííóþ str, ò.ê. ïîñëå çàêðûòèÿ
                // äèàëîãà ñòðîêà ââîäà óìðåò è òåêñò óæå èç íåå ïîëó÷èòü.
                // Ýòîò ìàêðîñ íà ñàìîì äåëå ïðåâðàùàåòñÿ â case èç îïåðàòîðà switch.
                // _wnd -- ýòî ïàðàìåòð îêîííîé ôóíêöèè, ñì. îïðåäåëåíèå ìàêðîñà TX_BEGIN_MESSAGE_MAP().
                //-------------------------------------------------------------------------------------------------
 
                TX_HANDLE (IDOK) GetDlgItemText (_wnd, ID_INPUT_, str, sizeof (str) - 1);
 
        TX_END_MESSAGE_MAP
 
        //---------------------------------------------------------------------------------------------------------
        // Êîíåö âíóòðåííåãî êëàññà äèàëîãà        //---------------------------------------------------------------------------------------------------------
        };

    //-------------------------------------------------------------------------------------------------------------
    // Óáèðàåì äåôàéíû, ÷òîáû ïîòîì íå ìåøàëè.
    // Îò ýòîãî îíè ïîëó÷àþòñÿ "ëîêàëüíîãî äåéñòâèÿ", êàê áóäòî ó íèõ áûëà áû îáëàñòü âèäèìîñòè -- ôóíêöèÿ. Íà ñàìîì
    // äåëå ýòî ñäåëàíî âðó÷íóþ ÷åðåç #undef. ×òîáû ïîä÷åðêíóòü èõ ëîêàëüíóþ ïðèðîäó, ó íèõ èìåíà çàêàí÷èâàþòñÿ íà _.
    // Òàêèå äåôàéíû ïîòîì íå ïåðåêîñÿ÷àò âåñü êîä ïîñëå òîãî êàê, ôàêòè÷åñêè, ñòàëè óæå íå íóæíû.
    //-------------------------------------------------------------------------------------------------------------

    #undef ID_TEXT_
    #undef ID_INPUT_

    //-------------------------------------------------------------------------------------------------------------
    // Ýòî ñòàòè÷åñêèé îáúåêò, ïîòîìó ÷òî ñòðîêà â íåì äîëæíà æèòü ïîñëå çàâåðøåíèÿ ôóíêöèè.
    //-------------------------------------------------------------------------------------------------------------

    static inputDlg dlg;

    //-------------------------------------------------------------------------------------------------------------
    // Ïåðåäàåì layout è çàïóñêàåì îêíî äèàëîãà
    //-------------------------------------------------------------------------------------------------------------

    dlg.dialogBox (layout);

    //-------------------------------------------------------------------------------------------------------------
    // Âîçâðàùàåì àäðåñ ñòðîêè èç ñòàòè÷åñêîãî îáúåêòà. Òàê ìîæíî äåëàòü, ïîòîìó ÷òî ñòàòè÷åñêèé îáúåêò íå óìðåò
    // ïðè âûõîäå èç ôóíêöèè è ñòðîêà â íåì, ñîîòâåòñòâåííî, òîæå. Àäðåñ íåñòàòè÷åñêèõ ïåðåìåííûõ ïåðåäàâàòü
    // ñèíòàêñè÷åñêè ìîæíî, íî âåäåò ê ñåðüåçíûì îøèáêàì.
    //-------------------------------------------------------------------------------------------------------------

    return dlg.str;
    }

//! @}
//}
//=================================================================================================================

//}
//=================================================================================================================

//=================================================================================================================
//{          TXLIB IMPLEMENTATION
//           Ðåàëèçàöèÿ ôóíêöèé áèáëèîòåêè
//=================================================================================================================
//! @cond INTERNAL

//=================================================================================================================
//{          DLL functions import, missing types definitions
//! @name    Èìïîðò âíåøíèõ áèáëèîòåê, îïðåäåëåíèå íåäîñòàþùèõ òèïîâ
//=================================================================================================================
//! @{

namespace Win32 {

//-----------------------------------------------------------------------------------------------------------------
//{ Some of structs, consts and interfaces aren't defined in MinGW some early headers.
//  Copied from Windows SDK 7.0a.
//-----------------------------------------------------------------------------------------------------------------

#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                             0x01
#endif

#ifndef SMTO_ERRORONEXIT
#define SMTO_ERRORONEXIT                         0x0020
#endif

#ifndef NT_CONSOLE_PROPS_SIG
#define NT_CONSOLE_PROPS_SIG                     0xA0000002
#endif

#ifndef NIIF_INFO
#define NIIF_INFO                                0x00000001
#define NIIF_WARNING                             0x00000002
#define NIIF_ERROR                               0x00000003
#endif

#ifndef NIF_INFO
#define NIF_STATE                                0x00000008
#define NIF_INFO                                 0x00000010
#endif

#ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
#define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS   0x00000004
#endif

#ifndef SYMOPT_CASE_INSENSITIVE
#define SYMOPT_CASE_INSENSITIVE                  0x00000001
#define SYMOPT_UNDNAME                           0x00000002
#define SYMOPT_DEFERRED_LOADS                    0x00000004
#define SYMOPT_NO_CPP                            0x00000008
#define SYMOPT_LOAD_LINES                        0x00000010
#define SYMOPT_OMAP_FIND_NEAREST                 0x00000020
#define SYMOPT_LOAD_ANYTHING                     0x00000040
#define SYMOPT_IGNORE_CVREC                      0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS              0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS              0x00000200
#define SYMOPT_EXACT_SYMBOLS                     0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS            0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH                 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES             0x00002000
#define SYMOPT_PUBLICS_ONLY                      0x00004000
#define SYMOPT_NO_PUBLICS                        0x00008000
#define SYMOPT_AUTO_PUBLICS                      0x00010000
#define SYMOPT_NO_IMAGE_SEARCH                   0x00020000
#define SYMOPT_SECURE                            0x00040000
#define SYMOPT_NO_PROMPTS                        0x00080000
#define SYMOPT_ALLOW_ZERO_ADDRESS                0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT         0x02000000
#define SYMOPT_FAVOR_COMPRESSED                  0x00800000
#define SYMOPT_FLAT_DIRECTORY                    0x00400000
#define SYMOPT_IGNORE_IMAGEDIR                   0x00200000
#define SYMOPT_OVERWRITE                         0x00100000
#define SYMOPT_DEBUG                             0x80000000
#endif

// SEH exception codes. For GCC, see http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 64-66.

#ifndef STATUS_POSSIBLE_DEADLOCK
#define STATUS_POSSIBLE_DEADLOCK                 0xC0000194
#endif

#ifndef STATUS_FLOAT_MULTIPLE_FAULTS
#define STATUS_FLOAT_MULTIPLE_FAULTS             0xC00002B4
#endif

#ifndef STATUS_STACK_BUFFER_OVERRUN
#define STATUS_STACK_BUFFER_OVERRUN              0xC0000409
#endif

#ifndef STATUS_ASSERTION_FAILURE
#define STATUS_ASSERTION_FAILURE                 0xC0000420
#endif

#ifndef STATUS_WX86_BREAKPOINT
#define STATUS_WX86_BREAKPOINT                   0x4000001F
#endif

#ifndef DBG_PRINTEXCEPTION_C
#define DBG_PRINTEXCEPTION_C                     0x40010006  // OutputDebugStringA() call
#endif

#ifndef DBG_PRINTEXCEPTION_WIDE_C
#define DBG_PRINTEXCEPTION_WIDE_C                0x4001000A  // OutputDebugStringW() call
#endif

#ifndef DBG_THREAD_NAME
#define DBG_THREAD_NAME                          0x406D1388
#endif

#define EXCEPTION_CPP_MSC                        0xE06D7363  // '?msc'
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1       0x19930520  // '?msc' version magic, see ehdata.h
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2       0x19930521  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3       0x19930522  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1  0x01994000  // '?msc' version magic

#define EXCEPTION_CPP_GCC                        0x20474343  // ' GCC'
#define EXCEPTION_CPP_GCC_UNWIND                 0x21474343  // '!GCC'
#define EXCEPTION_CPP_GCC_FORCED                 0x22474343  // '"GCC'

#define EXCEPTION_CLR_FAILURE                    0xE0434f4D  // 'àCOM'

#define EXCEPTION_CPP_BORLAND_BUILDER            0x0EEDFAE6  // Should never occur here
#define EXCEPTION_CPP_BORLAND_DELPHI             0x0EEDFADE  // Should never occur here

#pragma pack (push, 1)

struct CONSOLE_CURSOR_INFO
    {
    DWORD dwSize;
    BOOL bVisible;
    };

struct CONSOLE_FONT_INFO
    {
    DWORD nFont;
    COORD dwFontSize;
    };

struct CONSOLE_FONT_INFOEX
    {
    ULONG cbSize;
    DWORD nFont;
    COORD dwFontSize;
    UINT  FontFamily;
    UINT  FontWeight;
    WCHAR FaceName[LF_FACESIZE];
    };

struct DATABLOCK_HEADER
    {
    DWORD cbSize;
    DWORD dwSignature;
    };

struct NT_CONSOLE_PROPS
    {
    DATABLOCK_HEADER dbh;

    WORD  wFillAttribute;
    WORD  wPopupFillAttribute;
    COORD dwScreenBufferSize;
    COORD dwWindowSize;
    COORD dwWindowOrigin;
    DWORD nFont;
    DWORD nInputBufferSize;
    COORD dwFontSize;
    UINT  uFontFamily;
    UINT  uFontWeight;
    WCHAR FaceName[LF_FACESIZE];
    UINT  uCursorSize;
    BOOL  bFullScreen;
    BOOL  bQuickEdit;
    BOOL  bInsertMode;
    BOOL  bAutoPosition;
    UINT  uHistoryBufferSize;
    UINT  uNumberOfHistoryBuffers;
    BOOL  bHistoryNoDup;

    COLORREF ColorTable[16];
    };

#pragma pack (pop)

#undef  INTERFACE
#define INTERFACE IShellLinkDataList

DECLARE_INTERFACE_ (IShellLinkDataList, IUnknown)
    {
    // *** IUnknown methods ***
    STDMETHOD (QueryInterface)  (THIS_ REFIID iid, void** value)    _tx_override PURE;
    STDMETHOD_(ULONG, AddRef)   (THIS)                              _tx_override PURE;
    STDMETHOD_(ULONG, Release)  (THIS)                              _tx_override PURE;

    // *** IShellLinkDataList methods ***
    STDMETHOD (AddDataBlock)    (THIS_ void* dataBlock)             PURE;
    STDMETHOD (CopyDataBlock)   (THIS_ DWORD sig, void** dataBlock) PURE;
    STDMETHOD (RemoveDataBlock) (THIS_ DWORD sig)                   PURE;
    STDMETHOD (GetFlags)        (THIS_ DWORD* flags)                PURE;
    STDMETHOD (SetFlags)        (THIS_ DWORD  flags)                PURE;

    protected:
    virtual ~IShellLinkDataList();
    };

const GUID IID_IShellLink         = {0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID IID_IShellLinkDataList = {0x45e2b4ae, 0xb1c3, 0x11d0, {0xb9,0x2f,0x00,0xa0,0xc9,0x03,0x12,0xe1}};
const GUID IID_IPersistFile       = {0x0000010b, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};

const GUID CLSID_SpVoice          = {0x96749377, 0x3391, 0x11d2, {0x9e,0xe3,0x00,0xc0,0x4f,0x79,0x73,0x96}};
const GUID IID_ISpVoice           = {0x6c44df74, 0x72b9, 0x4992, {0xa1,0xec,0xef,0x99,0x6e,0x04,0x22,0xd4}};

#undef  INTERFACE

typedef DWORD     NTSTATUS;
typedef ULONG_PTR KAFFINITY;
typedef LONG      KPRIORITY;

struct UNICODE_STRING
    {
    USHORT Length;
    USHORT MaximumLength;
    WCHAR* Buffer;
    };

struct RTL_USER_PROCESS_PARAMETERS
    {
    BYTE  Reserved1[16];
    void* Reserved2[10];
    UNICODE_STRING ImagePathName;
    UNICODE_STRING CommandLine;
    };

struct PEB
    {
    BYTE  Reserved1[2];
    BYTE  BeingDebugged;
    BYTE  Reserved2[1];
    void* Reserved3[2];
    void* Ldr;
    RTL_USER_PROCESS_PARAMETERS* ProcessParameters;
    void* Reserved4[3];
    void* AtlThunkSListPtr;
    void* Reserved5;
    ULONG Reserved6;
    void* Reserved7;
    ULONG Reserved8;
    ULONG AtlThunkSListPtr32;
    void* Reserved9[45];
    BYTE  Reserved10[96];
    void* PostProcessInitRoutine;
    BYTE  Reserved11[128];
    void* Reserved12[1];
    ULONG SessionId;
    };

struct PROCESS_BASIC_INFORMATION
    {
    NTSTATUS  ExitStatus;
    PEB*      PebBaseAddress;
    KAFFINITY AffinityMask;
    KPRIORITY BasePriority;
    ULONG_PTR UniqueProcessId;
    ULONG_PTR InheritedFromUniqueProcessId;
    };

enum ADDRESS_MODE
    {
    AddrMode1616,
    AddrMode1632,
    AddrModeReal,
    AddrModeFlat
    };

struct ADDRESS64
    {
    DWORD64      Offset;
    WORD         Segment;
    ADDRESS_MODE Mode;
    };

struct KDHELP64
    {
    DWORD64 Thread;
    DWORD   ThCallbackStack;
    DWORD   ThCallbackBStore;
    DWORD   NextCallback;
    DWORD   FramePointer;
    DWORD64 KiCallUserMode;
    DWORD64 KeUserCallbackDispatcher;
    DWORD64 SystemRangeStart;
    DWORD64 KiUserExceptionDispatcher;
    DWORD64 StackBase;
    DWORD64 StackLimit;
    DWORD64 Reserved[5];
    };

struct STACKFRAME64
    {
    ADDRESS64 AddrPC;
    ADDRESS64 AddrReturn;
    ADDRESS64 AddrFrame;
    ADDRESS64 AddrStack;
    ADDRESS64 AddrBStore;
    PVOID     FuncTableEntry;
    DWORD64   Params[4];
    BOOL      Far;
    BOOL      Virtual;
    DWORD64   Reserved[3];
    KDHELP64  KdHelp;
    };

struct WOW64_FLOATING_SAVE_AREA
    {
    DWORD ControlWord;
    DWORD StatusWord;
    DWORD TagWord;
    DWORD ErrorOffset;
    DWORD ErrorSelector;
    DWORD DataOffset;
    DWORD DataSelector;
    BYTE  RegisterArea[80];
    DWORD Cr0NpxState;
    };

#pragma pack (push, 4)

struct WOW64_CONTEXT
    {
    DWORD ContextFlags;

    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;

    WOW64_FLOATING_SAVE_AREA FloatSave;

    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;

    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;

    DWORD Ebp;
    DWORD Eip;
    DWORD SegCs;
    DWORD EFlags;
    DWORD Esp;
    DWORD SegSs;

    BYTE  ExtendedRegisters[512];
    };

#pragma pack (pop)

struct SYMBOL_INFO
    {
    ULONG   SizeOfStruct;
    ULONG   TypeIndex;
    ULONG64 Reserved[2];
    ULONG   info;
    ULONG   Size;
    ULONG64 ModBase;
    ULONG   Flags;
    ULONG64 Value;
    ULONG64 Address;
    ULONG   Register;
    ULONG   Scope;
    ULONG   Tag;
    ULONG   NameLen;
    ULONG   MaxNameLen;
    CHAR    Name[1];
    };

struct IMAGEHLP_LINE64
    {
    DWORD   SizeOfStruct;
    PVOID   Key;
    DWORD   LineNumber;
    PCHAR   FileName;
    DWORD64 Address;
    };

typedef bool    (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)   (HANDLE process, DWORD64 baseAddress, void* buffer, DWORD size, DWORD* bytesRead);
typedef void*   (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64) (HANDLE process, DWORD64 baseAddress);
typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)       (HANDLE process, DWORD64 address);
typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)     (HANDLE process, HANDLE thread, ADDRESS64* address);

typedef void (*unexpected_handler)();

#pragma pack (push, 4)

struct MINIDUMP_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    };

struct MINIDUMP_THREAD_EX_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    ULONG64  BackingStoreBase;
    ULONG64  BackingStoreEnd;
    };

struct MINIDUMP_MODULE_CALLBACK
    {
    wchar_t* FullPath;
    ULONG64  BaseOfImage;
    ULONG    SizeOfImage;
    ULONG    CheckSum;
    ULONG    TimeDateStamp;
    VS_FIXEDFILEINFO VersionInfo;
    void*    CvRecord;
    ULONG    SizeOfCvRecord;
    PVOID    MiscRecord;
    ULONG    SizeOfMiscRecord;
    };

struct MINIDUMP_INCLUDE_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    };

struct MINIDUMP_INCLUDE_MODULE_CALLBACK
    {
    ULONG64  BaseOfImage;
    };

struct MINIDUMP_MEMORY_INFO
    {
    ULONG64  BaseAddress;
    ULONG64  AllocationBase;
    ULONG32  AllocationProtect;
    ULONG32  __alignment1;
    ULONG64  RegionSize;
    ULONG32  State;
    ULONG32  Protect;
    ULONG32  Type;
    ULONG32  __alignment2;
    };

struct MINIDUMP_USER_STREAM
    {
    ULONG32  Type;
    ULONG    BufferSize;
    PVOID    Buffer;
    };

struct MINIDUMP_USER_STREAM_INFORMATION
    {
    ULONG                 UserStreamCount;
    MINIDUMP_USER_STREAM* UserStreamArray;
    };

struct MINIDUMP_CALLBACK_INPUT
    {
    ULONG    ProcessId;
    HANDLE   ProcessHandle;
    ULONG    CallbackType;

    union
        {
        MINIDUMP_THREAD_CALLBACK         Thread;
        MINIDUMP_THREAD_EX_CALLBACK      ThreadEx;
        MINIDUMP_MODULE_CALLBACK         Module;
        MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
        MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
        };
    };

struct MINIDUMP_CALLBACK_OUTPUT
    {
    union
        {
        ULONG ModuleWriteFlags;
        ULONG ThreadWriteFlags;
        ULONG SecondaryFlags;

        struct
            {
            ULONG64  MemoryBase;
            ULONG    MemorySize;
            };

        struct
            {
            unsigned CheckCancel;
            unsigned Cancel;
            };

        HANDLE Handle;
        };

    struct
        {
        MINIDUMP_MEMORY_INFO VmRegion;
        unsigned             Continue;
        };

    HRESULT Status;
    };

struct MINIDUMP_EXCEPTION_INFORMATION
    {
    DWORD               ThreadId;
    EXCEPTION_POINTERS* ExceptionPointers;
    unsigned            ClientPointers;
    };

typedef int (WINAPI* MINIDUMP_CALLBACK_ROUTINE) (void* param, MINIDUMP_CALLBACK_INPUT* input, MINIDUMP_CALLBACK_OUTPUT* output);

struct MINIDUMP_CALLBACK_INFORMATION
    {
    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
    void*                     CallbackParam;
    };

enum MINIDUMP_TYPE
    {
    MiniDumpNormal                         = 0x00000000,
    MiniDumpWithDataSegs                   = 0x00000001,
    MiniDumpWithFullMemory                 = 0x00000002,
    MiniDumpWithHandleData                 = 0x00000004,
    MiniDumpFilterMemory                   = 0x00000008,
    MiniDumpScanMemory                     = 0x00000010,
    MiniDumpWithUnloadedModules            = 0x00000020,
    MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
    MiniDumpFilterModulePaths              = 0x00000080,
    MiniDumpWithProcessThreadData          = 0x00000100,
    MiniDumpWithPrivateReadWriteMemory     = 0x00000200,
    MiniDumpWithoutOptionalData            = 0x00000400,
    MiniDumpWithFullMemoryInfo             = 0x00000800,
    MiniDumpWithThreadInfo                 = 0x00001000,
    MiniDumpWithCodeSegs                   = 0x00002000,
    MiniDumpWithoutAuxiliaryState          = 0x00004000,
    MiniDumpWithFullAuxiliaryState         = 0x00008000,
    MiniDumpWithPrivateWriteCopyMemory     = 0x00010000,
    MiniDumpIgnoreInaccessibleMemory       = 0x00020000,
    MiniDumpWithTokenInformation           = 0x00040000
    };

#pragma pack (pop)

#define FOREGROUND_BLACK         ( 0                                                         )
#define FOREGROUND_CYAN          ( FOREGROUND_BLUE       | FOREGROUND_GREEN                  )
#define FOREGROUND_MAGENTA       ( FOREGROUND_BLUE       | FOREGROUND_RED                    )
#define FOREGROUND_DARKYELLOW    ( FOREGROUND_GREEN      | FOREGROUND_RED                    )
#define FOREGROUND_LIGHTGRAY     ( FOREGROUND_BLUE       | FOREGROUND_GREEN | FOREGROUND_RED )
#define FOREGROUND_DARKGRAY      (                         FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTBLUE     ( FOREGROUND_BLUE       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTGREEN    ( FOREGROUND_GREEN      | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTCYAN     ( FOREGROUND_CYAN       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTRED      ( FOREGROUND_RED        | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTMAGENTA  ( FOREGROUND_MAGENTA    | FOREGROUND_INTENSITY              )
#define FOREGROUND_YELLOW        ( FOREGROUND_DARKYELLOW | FOREGROUND_INTENSITY              )
#define FOREGROUND_WHITE         ( FOREGROUND_LIGHTGRAY  | FOREGROUND_INTENSITY              )

#define BACKGROUND_BLACK         ( 0                                                         )
#define BACKGROUND_CYAN          ( BACKGROUND_BLUE       | BACKGROUND_GREEN                  )
#define BACKGROUND_MAGENTA       ( BACKGROUND_BLUE       | BACKGROUND_RED                    )
#define BACKGROUND_DARKYELLOW    ( BACKGROUND_GREEN      | BACKGROUND_RED                    )
#define BACKGROUND_GRAY          ( BACKGROUND_BLUE       | BACKGROUND_GREEN | BACKGROUND_RED )
#define BACKGROUND_DARKGRAY      (                         BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTBLUE     ( BACKGROUND_BLUE       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTGREEN    ( BACKGROUND_GREEN      | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTCYAN     ( BACKGROUND_CYAN       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTRED      ( BACKGROUND_RED        | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTMAGENTA  ( BACKGROUND_MAGENTA    | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTYELLOW   ( BACKGROUND_DARKYELLOW | BACKGROUND_INTENSITY              )
#define BACKGROUND_WHITE         ( BACKGROUND_DARKGRAY   | BACKGROUND_INTENSITY              )

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ There are copies of MSVC compiler built-in predefined definitions, which are wrong in 64-bit mode.
//  So we have to override them. See: http://stackoverflow.com/questions/39113168
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)
                                                    //  MS ABI C++ Exception Layout
namespace Win32 {                                   //  ---------------------------
                                                    //
#pragma pack (push, 4)                              //   EXCEPTION_RECORD:
                                                    //  +==================================================+
struct ThrowInfo                                    //  |...                                               |
    {                                               //  |NumberParameters:        3, 4 or more             |
    __int32 attributes;                             //  |ExceptionInformation[0]: MS signature 0x19930520  |
    __int32 pmfnUnwind;                             //  |ExceptionInformation[1]: object* thrown           |
    __int32 pForwardCompat;                         //  |ExceptionInformation[2]: ThrowInfo* --------------+---+
    __int32 pCatchableTypeArray;                    //  |ExceptionInformation[3]: ImageBase (if params > 3)|   |
    };                                              //  +==================================================+   |
                                                    //                                                         |
struct CatchableTypeArray                           //        ThrowInfo:                                       |
    {                                               //        +======================================+ <-------+
    __int32 nCatchableTypes;                        //        |   ...                                |
    __int32 arrayOfCatchableTypes[];                //  +-----+-- pCatchableTypeArray (ptr/RVA)      |
    };                                              //  |     +======================================+
                                                    //  |
struct CatchableType                                //  |     CatchableTypeArray:
    {                                               //  +---> +======================================+
    __int32 properties;                             //        |   ...                                |
    __int32 pType;                                  //  +-----+-- arrayOfCatchableTypes[0] (ptr/RVA) |
    __int32 thisDisplacement[3]; // struct _PMD     //  |     +======================================+
    __int32 sizeOrOffset;                           //  |
    __int32 copyFunction;                           //  |     CatchableType:
    };                                              //  +---> +====================+
                                                    //        | ...                |        std::type_info:
#pragma pack (pop)                                  //        | pType (ptr/RVA) ---+------> +==================+
                                                    //        | ...                |        |type_info data    |
} // namespace Win32                                //        +====================+        |...               |
                                                    //                                      +==================+
#endif

// Similar to __CxxDetectRethrow(), see C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\crtsrc\vcruntime\frame.cpp:

#define _TX_MSC__CXX_DETECT_RETHROW( exc )                                     \
    (                                                                          \
    (exc)                                          &&                          \
    (exc) -> ExceptionCode    == EXCEPTION_CPP_MSC &&                          \
    (exc) -> NumberParameters >= 3                 &&                          \
                                                                               \
    ((exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3) && \
                                                                               \
    (exc) -> ExceptionInformation[2] == 0                                      \
    )

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ The corresponding structures for GCC
//
//  From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/unwind-cxx.h
//  See:  http://mentorembedded.github.io/cxx-abi/abi-eh.html#cxx-abi
//-----------------------------------------------------------------------------------------------------------------

#if defined (_GCC_VER)
                                                    // GCC ABI C++ Exception layout. A/B are ExceptionInformation[0].
namespace ABI {                                     // --------------------------------------------------------------
                                                    //
struct __cxa_exception                              // Case A: "_Unwind_Exception* A" is undependent exception:
    {                                               // --------------------------------------------------------
    union {                                         //
        struct                                      //           __cxa_exception:           std::type_info:
            {                                       //       -*--+====================+     +==================+
            ::std::type_info* exceptionType;        //        ^  |exceptionType* -----+---->|type_info data    |
            void (*exceptionDestructor)(void*);     //        |  |...                 |     |...               |
            };                                      //       -1  |                    |     +==================+
        struct                                      //        |  |                    |
            {                                       // A >----|--+--------------------+
            __cxa_exception*  primaryException;     //     |  |  |unwindHeader        |
            void (*padding)();                      //    +1  |  |                    |
            };                                      //     |  |  |                    |
        };                                          //     V  |  |                    |
                                                    //    -*---  +====================+
    std::unexpected_handler   unexpectedHandler;    //           |object              |
    std::terminate_handler    terminateHandler;     //           +--------------------+
                                                    //
    __cxa_exception*          nextException;        // Case B: "_Unwind_Exception* B" is dependent exception
    int                       handlerCount;         // (unwindHeader.exception_class & 1 != 0):
    int                       handlerSwitchValue;   // -----------------------------------------------------
    const unsigned char*      actionRecord;         //
    const unsigned char*      languageSpecificData; //           __cxa_exception:               __cxa_exception:
    void*                     catchTemp;            //       -*--+====================+     -*--+=================+
    void*                     adjustedPtr;          //        ^  |primaryException* --+--    ^  |exceptionType*   |
                                                    //        |  |...                 |  \   |  |...              |
    _Unwind_Exception         unwindHeader;         //       -1  |                    |  |   |  |                 |
    };                                              //        |  |                    |  |   |  |                 |
                                                    // B >----|--+--------------------+  |  -1  +-----------------+
struct __cxa_eh_globals                             //     |  |  |unwindHeader        |  |   |  |unwindHeader     |
    {                                               //    +1  |  |                    |  |   |  |                 |
    __cxa_exception* caughtExceptions;              //     |  |  |                    |  |   |  |                 |
    unsigned int     uncaughtExceptions;            //     V  |  |                    |  \   |  |                 |
    };                                              //    -*---  +====================+   -->*--+=================+
                                                    //           |...                 |         |object           |
} // namespace ABI                                  //           .                    .         |                 |
                                                    //                                          +-----------------+

extern "C" ABI::__cxa_eh_globals* __cxa_get_globals();

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ Hand-made IAT.
//  Some IDEs don't link with these libs by default in console projects, so do sunrise by hand. :(
//-----------------------------------------------------------------------------------------------------------------

// Hand-made DLLIMPORT helpers

#define _TX_DLLIMPORT(     lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, true)

#define _TX_DLLIMPORT_OPT( lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, false)

#define _TX_DLLIMPORT_CRT( lib, retval, name, params ) \
     retval (      * name) params = (retval (      *) params) _txDllImport (lib ".dll", #name, false)

typedef void (*_tx_FARPROC)();

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required = true);

//-----------------------------------------------------------------------------------------------------------------

namespace Win32 {

_TX_DLLIMPORT     ("GDI32",    HDC,      CreateCompatibleDC,            (HDC dc));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateCompatibleBitmap,        (HDC dc, int width, int height));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetStockObject,                (int object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  SelectObject,                  (HDC dc, HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetCurrentObject,              (HDC dc, unsigned objectType));
_TX_DLLIMPORT     ("GDI32",    int,      GetObjectA,                    (HGDIOBJ obj, int bufsize, void* buffer));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GetObjectType,                 (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteDC,                      (HDC dc));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteObject,                  (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetTextColor,                  (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetBkColor,                    (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    int,      SetBkMode,                     (HDC dc, int bkMode));
_TX_DLLIMPORT     ("GDI32",    HFONT,    CreateFontA,                   (int height, int width, int escapement, int orientation,
                                                                         int weight, DWORD italic, DWORD underline, DWORD strikeout,
                                                                         DWORD charSet, DWORD outputPrec, DWORD clipPrec,
                                                                         DWORD quality, DWORD pitchAndFamily, const char face[]));
_TX_DLLIMPORT     ("GDI32",    int,      EnumFontFamiliesExA,           (HDC dc, LPLOGFONT logFont, FONTENUMPROC enumProc,
                                                                         LPARAM lParam, DWORD reserved));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetPixel,                      (HDC dc, int x, int y, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, GetPixel,                      (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    HPEN,     CreatePen,                     (int penStyle, int width, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    HBRUSH,   CreateSolidBrush,              (COLORREF color));
_TX_DLLIMPORT     ("GDI32",    bool,     MoveToEx,                      (HDC dc, int x, int y, POINT* point));
_TX_DLLIMPORT     ("GDI32",    bool,     LineTo,                        (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    bool,     Polygon,                       (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Polyline,                      (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     PolyBezier,                    (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Rectangle,                     (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     RoundRect,                     (HDC dc, int x0, int y0, int x1, int y1, int sizeX, int sizeY));
_TX_DLLIMPORT     ("GDI32",    bool,     Ellipse,                       (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     Arc,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Pie,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Chord,                         (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     TextOutA,                      (HDC dc, int x, int y, const char string[], int length));
_TX_DLLIMPORT     ("GDI32",    UINT,     SetTextAlign,                  (HDC dc, unsigned mode));
_TX_DLLIMPORT     ("GDI32",    bool,     GetTextExtentPoint32A,         (HDC dc, const char string[], int length, SIZE* size));
_TX_DLLIMPORT     ("GDI32",    bool,     ExtFloodFill,                  (HDC dc, int x, int y, COLORREF color, unsigned type));
_TX_DLLIMPORT     ("GDI32",    bool,     BitBlt,                        (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src,  int xSrc,  int ySrc,  DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     StretchBlt,                    (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src, int xSrc, int ySrc, int wSrc, int hSrc, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     PlgBlt,                        (HDC dest, const POINT* parallelogram,
                                                                         HDC src, int xSrc, int ySrc, int width, int height,
                                                                         HBITMAP mask, int xMask, int yMask));
_TX_DLLIMPORT     ("GDI32",    int,      SetDIBitsToDevice,             (HDC dc, int xDest, int yDest, DWORD width, DWORD height,
                                                                         int xSrc, int ySrc, unsigned startLine, unsigned numLines,
                                                                         const void* data, const BITMAPINFO* info, unsigned colorUse));
_TX_DLLIMPORT     ("GDI32",    int,      GetDIBits,                     (HDC hdc, HBITMAP hbmp, unsigned uStartScan, unsigned cScanLines,
                                                                         void* lpvBits, BITMAPINFO* lpbi, unsigned usage));
_TX_DLLIMPORT     ("GDI32",    bool,     PatBlt,                        (HDC dc, int x0, int y0, int width, int height, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    int,      SetROP2,                       (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    int,      SetStretchBltMode,             (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GdiSetBatchLimit,              (DWORD limit));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateDIBSection,              (HDC dc, const BITMAPINFO* bmInfo, unsigned colorUsage, void **vBits,
                                                                         HANDLE section, DWORD offset));

_TX_DLLIMPORT     ("User32",   int,      DrawTextA,                     (HDC dc, const char text[], int length, RECT* rect, unsigned format));
_TX_DLLIMPORT     ("User32",   HANDLE,   LoadImageA,                    (HINSTANCE inst, const char name[], unsigned type,
                                                                        int sizex, int sizey, unsigned mode));
_TX_DLLIMPORT_OPT ("User32",   bool,     IsHungAppWindow,               (HWND wnd));
_TX_DLLIMPORT_OPT ("User32",   HWND,     GhostWindowFromHungWindow,     (HWND wnd));

_TX_DLLIMPORT     ("WinMM",    bool,     PlaySound,                     (const char sound[], HMODULE mod, DWORD mode));

_TX_DLLIMPORT_OPT ("MSImg32",  bool,     TransparentBlt,                (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         unsigned transparentColor));
_TX_DLLIMPORT_OPT ("MSImg32",  bool,     AlphaBlend,                    (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         BLENDFUNCTION blending));

_TX_DLLIMPORT     ("Kernel32", void,     ExitProcess,                   (unsigned retcode));
_TX_DLLIMPORT     ("Kernel32", bool,     TerminateProcess,              (HANDLE process, unsigned retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalExit,                     (int retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalAppExitA,                 (unsigned action, const char message[]));
_TX_DLLIMPORT     ("Kernel32", HWND,     GetConsoleWindow,              (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetConsoleFont,                (HANDLE con, DWORD fontIndex));
_TX_DLLIMPORT_OPT ("Kernel32", DWORD,    GetNumberOfConsoleFonts,       (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFont,         (HANDLE con, bool maxWnd, CONSOLE_FONT_INFO*   curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", void,     RtlCaptureContext,             (CONTEXT* contextRecord));
_TX_DLLIMPORT_OPT ("Kernel32", USHORT,   RtlCaptureStackBackTrace,      (DWORD framesToSkip, DWORD framesToCapture, void** backTrace, DWORD* hash));
_TX_DLLIMPORT_OPT ("Kernel32", void*,    AddVectoredExceptionHandler,   (unsigned long firstHandler, PVECTORED_EXCEPTION_HANDLER handler));
_TX_DLLIMPORT_OPT ("Kernel32", unsigned, RemoveVectoredExceptionHandler,(void* handler));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetModuleHandleEx,             (DWORD flags, const char moduleName[], HMODULE* module));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     IsWow64Process,                (HANDLE process, int* isWow64Process));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     Wow64GetThreadContext,         (HANDLE thread, WOW64_CONTEXT* context));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetThreadStackGuarantee,       (unsigned long* stackSize));

_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoInitialize,                  (void*));
_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoCreateInstance,              (REFCLSID clsId, IUnknown*, DWORD, REFIID iId, PVOID* value));
_TX_DLLIMPORT     ("OLE32",    void,     CoUninitialize,                (void));

_TX_DLLIMPORT     ("Shell32",  HINSTANCE,ShellExecuteA,                 (HWND wnd, const char operation[], const char file[],
                                                                         const char parameters[], const char directory[], int showCmd));

_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIA,                      (const char    string[], const char    search[]));
_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIW,                      (const wchar_t string[], const wchar_t search[]));

_TX_DLLIMPORT_OPT ("NTDLL",    char*,    wine_get_version,              (void));
_TX_DLLIMPORT     ("NTDLL",    NTSTATUS, NtQueryInformationProcess,     (HANDLE process, int infoClass,
                                                                         void* processInfo, unsigned long szProcessInfo, unsigned long* szReturnInfo));

_TX_DLLIMPORT_CRT ("MSVCRT",   void,     exit,                          (int retcode));
_TX_DLLIMPORT_CRT ("MSVCRT",   void,     _cexit,                        (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _fpreset,                      (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _controlfp,                    (unsigned control, unsigned mask));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthread,                  (void (__cdecl* start_address) (void*), unsigned stack_size, void* arglist));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthreadex,                (void* security, unsigned stack_size, unsigned (__stdcall* start_address) (void*),
                                                                         void *arglist, unsigned init_flag, unsigned* thread_addr));
_TX_DLLIMPORT_CRT ("MSVCRT",   char*,    __unDName,                     (char* outStr, const char* mangledName, int outStrLen,
                                                                         void* (*mallocFunc) (size_t size), void (*freeFunc) (void *pointer),
                                                                         unsigned short flags));
_TX_DLLIMPORT_CRT ("MSVCRT",   unexpected_handler, set_unexpected,      (unexpected_handler handler));

_TX_DLLIMPORT_OPT ("OpenGL32", HDC,         wglGetCurrentDC,            (void));
_TX_DLLIMPORT_OPT ("OpenGL32", unsigned,    glGetError,                 (void));
_TX_DLLIMPORT_OPT ("Glu32",    const char*, gluErrorString,             (unsigned error));

_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     MiniDumpWriteDump,             (HANDLE process, DWORD processId, HANDLE file, MINIDUMP_TYPE dumpType,
                                                                         MINIDUMP_EXCEPTION_INFORMATION*   exceptionParam,
                                                                         MINIDUMP_USER_STREAM_INFORMATION* userStreamParam,
                                                                         MINIDUMP_CALLBACK_INFORMATION*    callbackParam));

_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("DbgHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
namespace MinGW {
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("MgwHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
} // namespace MinGW

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal function prototypes, macros and constants
//  @name    Ïðîòîòèïû âíóòðåííèõ ôóíêöèé, ìàêðîñû è êîíñòàíòû
//=================================================================================================================
//! @{

const int        _TX_IDM_ABOUT                            =   40000,       // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
                 _TX_IDM_CONSOLE                          =   40001,
                 _TX_WM_CREATEWND                         =   0x7FF0,      // Ñîîáùåíèÿ äëÿ ñîçäàíèÿ/óíè÷òîæåíèÿ
                 _TX_WM_DESTROYWND                        =   0x7FF1;      // îêîí â ïîòîêå Canvas

//-----------------------------------------------------------------------------------------------------------------

int              _txInitialize();
void             _txCleanup();

HWND             _txCanvas_CreateWindow      (const SIZE* size);
inline bool      _txCanvas_OK() tx_nodiscard;

bool             _txCanvas_OnCREATE          (HWND wnd);
bool             _txCanvas_OnDESTROY         (HWND wnd);
bool             _txCanvas_OnCLOSE           (HWND);
bool             _txCanvas_OnPAINT           (HWND wnd);
bool             _txCanvas_OnKEYDOWN         (HWND wnd, WPARAM vk, LPARAM info);
bool             _txCanvas_OnCHAR            (HWND wnd, WPARAM ch, LPARAM info);
bool             _txCanvas_OnTIMER           (HWND wnd, WPARAM id);
bool             _txCanvas_OnMOUSEMOVE       (HWND wnd, WPARAM buttons, LPARAM coords);
bool             _txCanvas_OnMOUSELEAVE      (HWND wnd);
bool             _txCanvas_OnCREATEWND       (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnDESTROYWND      (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnCmdCONSOLE      (HWND wnd, WPARAM cmd);
bool             _txCanvas_OnCmdABOUT        (HWND wnd, WPARAM cmd);

unsigned WINAPI  _txCanvas_ThreadProc        (void* data);
LRESULT CALLBACK _txCanvas_WndProc           (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);

int              _txCanvas_SetRefreshLock    (int count);

HDC              _txBuffer_Create            (HWND wnd = NULL, const POINT* size = NULL, HBITMAP bitmap = NULL,
                                              RGBQUAD** pixels = NULL) tx_nodiscard;
bool             _txBuffer_Delete            (HDC* dc);
bool             _txBuffer_Select            (HGDIOBJ obj, HDC dc = txDC());

HWND             _txConsole_Attach();
bool             _txConsole_OK() tx_nodiscard;
bool             _txConsole_Detach           (bool activate);
bool             _txConsole_Draw             (HDC dc);
bool             _txConsole_SetUnicodeFont();

const char*       txRegisterClass            (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra);
HWND              txCreateExtraWindow        (CREATESTRUCT createData);
HICON            _txCreateTXIcon             (int size) tx_nodiscard;
int              _txSetFinishedText          (HWND wnd);
void             _txPauseBeforeTermination   (HWND canvas);
int              _txIsParentWaitable         (DWORD* parentPID = NULL) tx_nodiscard;
int              _txGetInput();

LRESULT CALLBACK _txPlayVideo_WndProc        (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
const char*      _txPlayVideo_FindVLC() tx_nodiscard;

bool             _txCreateShortcut           (const char shortcutName[],
                                              const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
                                              const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
                                              const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
                                              COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));

void*            _tx_DLGTEMPLATE_Create      (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                                              WORD controls, short x, short y, short cx, short cy,
                                              const char caption[], const char font[], WORD fontsize,
                                              const char menu[]) tx_nodiscard;

void*            _tx_DLGTEMPLATE_Add         (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                                              short x, short y, short cx, short cy,
                                              WORD id, const char wclass[], const char caption[]);

const char*      _txError                    (const char file[] = NULL, int line = 0, const char func[] = NULL, unsigned color = 0,
                                              const char msg[] = NULL, ...) tx_printfy (5);
const char*      _txProcessError             (const char file[], int line, const char func[], unsigned color,
                                              const char msg[], va_list args);
void             _txOnTerminate();
void             _txOnUnexpected();
void             _txOnPureCall();
void             _txOnNewHandlerAnsi();
int              _txOnNewHandler             (size_t size);
void             _txOnSignal                 (int signal = 0, int fpe = 0);
BOOL WINAPI      _txOnConsoleCtrlEvent       (DWORD type);
void             _txOnSecurityError          (int code, void*);
void             _txOnSecurityErrorAnsi      (const char* msg, void* ptr, int code);
int              _txOnMatherr                (_exception* except);
void             _txOnInvalidParam           (const wchar_t* expr, const wchar_t* func, const wchar_t* file,
                                              unsigned line, uintptr_t);
int              _txOnAllocHook              (int type, void* data, size_t size, int use, long request,
                                              const unsigned char* file, int line);
int              _txOnRTCFailure             (int type, const char* file, int line, const char* module, const char* format, ...) tx_printfy (5);
int              _txOnErrorReport            (int type, const char* text, int* ret);
int               tx_glGetError              (int setError = INT_MIN);

void             _txOnCExit();
void             _txOnExit                   (int      retcode);
void             _txOnFatalExit              (int      retcode);
void             _txOnExitProcess            (unsigned retcode);
void             _txOnFatalAppExitA          (unsigned action, const char message[]);
bool             _txOnTerminateProcess       (HANDLE process, unsigned retcode);
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
                 _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter);
void             _txWatchdogTerminator       (void* timeout);  // Only Arnold-type series are supported, not T1000

long WINAPI      _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc);
long WINAPI      _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc);
long             _txOnExceptionSEH           (EXCEPTION_POINTERS* exc, const char func[]);
intptr_t         _txDumpExceptionSEH         (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[]);
intptr_t         _txDumpExceptionObj         (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type);
intptr_t         _txDumpExceptionCPP         (char what[], intptr_t size, unsigned code = 0,
                                              unsigned params = 0, const ULONG_PTR info[] = NULL);

void             _txStackBackTrace           (const char file[] = "?", int line = 0, const char func[] = "?",
                                              bool readSource = true);
const char*      _txCaptureStackBackTrace    (int framesToSkip = 0, bool readSource = true,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
int              _txStackWalk                (int framesToSkip, size_t szCapture, void* capture[], unsigned long* backTraceHash,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
const char*      _txCaptureStackBackTraceTX  (int framesToSkip = 0, bool readSource = false);

const char*      _txSymPrintFromAddr         (void* addr = NULL, const char format[] = NULL, ...) tx_printfy (2);
bool             _txSymGetFromAddr           (void* addr, Win32::SYMBOL_INFO** symbol = NULL,
                                              Win32::IMAGEHLP_LINE64** line = NULL, const char** module = NULL,
                                              const char** source = NULL, int context = 2);
intptr_t         _txReadSource               (char buf[], intptr_t size, const char file[],
                                              int linStart = 0, int linEnd = INT_MIN, int linMark = INT_MIN);
bool             _txCreateMiniDump           (EXCEPTION_POINTERS* exc);

uintptr_t        _txSetProcAddress           (const char funcName[], uintptr_t newFunc, const char dllName[] = NULL,
                                              int useHotPatching = false, HMODULE module = NULL, bool debug = false);
bool             _txInDll() tx_nodiscard;
PROCESSENTRY32*  _txFindProcess              (unsigned pid = GetCurrentProcessId()) tx_nodiscard;
bool             _txKillProcess              (DWORD pid);
bool             _txIsBadReadPtr             (const void* address);
bool             _txCheckSourceCP            (int needCP = _TX_CODEPAGE, bool verbose = true);
bool             _txGetCommandLine           (wchar_t cmdLine[], size_t szCmdLine, unsigned pid = _getpid());
IMAGE_NT_HEADERS*_txGetNtHeaders             (HMODULE module = GetModuleHandle (NULL)) tx_nodiscard;
const char*      _txAppInfo() tx_nodiscard;

intptr_t         _tx_snprintf_s              (char stream[], intptr_t size, const char format[], ...) tx_printfy (3);
intptr_t         _tx_vsnprintf_s             (char stream[], intptr_t size, const char format[], va_list arg);
void              txReopenStdio();

#if defined (_CLANG_VER) && !defined (_MSC_VER)
void             _txLibCppDebugFunction      (std::__libcpp_debug_info const& info);
#endif

#if defined (__CYGWIN__)

int              _getch();
int              _putch (int ch);
int              _kbhit() tx_nodiscard;

#endif

//-----------------------------------------------------------------------------------------------------------------
// There are macros for __FILE__ and __LINE__ to work properly.

#if !defined (NDEBUG)

    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) && \
                                                     (assert (cond), true) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå."), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("Ïàðàìåòð \"%s\" íåâåðåí. Âîçìîæíî, ýòîò õîëñò íå ñîçäàí, " \
                                                                "èëè óæå óíè÷òîæåí, èëè íå çàãðóçèëàñü êàðòèíêà.", #dc), 1) )
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( (!(dc) &&                                           \
                                                     _TX_TXWINDOW_FAILED()) || _TX_HDC_FAILED (dc) )

#else
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define _TX_DEFAULT_HDC_FAILED(dc)         ( !(dc) &&                                            \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
#endif

//-----------------------------------------------------------------------------------------------------------------
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but MSVC rejects it. So sad. :'(

#if !defined (NDEBUG)
    #define  _TX_ON_DEBUG( code )              { code; }
#else
    #define  _TX_ON_DEBUG( code )              ;
#endif

//-----------------------------------------------------------------------------------------------------------------
// Invokes an error without location information. "$$" restores TX-related call location context

#define _TX_UNEXPECTED( ... )                  $$ _txError (NULL, 0, NULL, 0, ##__VA_ARGS__)

//-----------------------------------------------------------------------------------------------------------------
// Safe call of a function via its pointer

#define _TX_CALL(  func, param )               ( (func)? ((func) param) :       0 )
#define _TX_CALLv( func, param )               ( (func)? ((func) param) : (void)0 )

//-----------------------------------------------------------------------------------------------------------------
// This is a macro because cond is an expression and is not always a function. Lack of lambdas in pre-C++0x.

#define      _txWaitFor( cond, time )          { for (DWORD _t = GetTickCount() + (time); \
                                                      !(cond) && GetTickCount() < _t;     \
                                                      Sleep (_txWindowUpdateInterval)) ;  \
                                                 if  (!(cond))                            \
                                                      _txTrace (__FILE__, __LINE__, NULL, "WARNING: Timeout: " #cond "."); }
//-----------------------------------------------------------------------------------------------------------------
// Detouring in case of SEH mechanism

#define _txSetJmp()                            ( setjmp (_txDumpExceptionObjJmp) == 0 )

#define _txClearJmp()                          { *(unsigned long long*) _txDumpExceptionObjJmp = 0; }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal global data
//! @name    Âíóòðåííèå ãëîáàëüíûå äàííûå
//
//           Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
//           Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåð, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
//           Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
//           Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé, èëè êëàññ.
//=================================================================================================================
//! @{

int                          _txInitialized              = _TX_NOINIT || _txInitialize();

volatile const unsigned      _txCanaryFirst              = 0x776F656D; // A very system value

volatile unsigned            _txMainThreadId             = 0;          // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
volatile HANDLE              _txMainThread               = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà

volatile unsigned            _txCanvas_ThreadId          = 0;          // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
volatile HANDLE              _txCanvas_Thread            = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
volatile HWND                _txCanvas_Window            = NULL;       // Äåñêðèïòîð îêíà õîëñòà TXLib

HDC                          _txCanvas_BackBuf[2]        = {NULL,      // [0] Main TXLib in-memory DC, where user's pictures lies
                                                            NULL};     // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()

RGBQUAD*                     _txCanvas_Pixels            = NULL;       // Memory buffer of _txCanvas_BackBuf[0]

HBITMAP                      _txStockBitmap              = NULL;       // Equivalent of GetStockObject (BITMAP),
                                                                       // see https://devblogs.microsoft.com/oldnewthing/20100416-00/?p=14313

CRITICAL_SECTION             _txCanvas_LockBackBuf       = {0,-1};     // Prevent simultaneous access to back buffer, see txLock()

UINT_PTR                     _txCanvas_RefreshTimer      = 1;          // Timer ID to redraw TXLib window
volatile int                 _txCanvas_RefreshLock       = 0;          // Blocks auto on-timer canvas update, see txBegin/txEnd

::std::vector<HDC>*          _txCanvas_UserDCs           = NULL;       // List of DCs allocated, for auto-free

volatile bool                _txConsole_IsBlinking       = true;       // To blink or not to blink, that is the question.

bool                         _txConsole                  = false;      // Only first TXLib module in app can own the console
bool                         _txMain                     = false;      // First TXLib wnd opened (closing it terminates program)
bool                         _txIsDll                    = false;      // TXLib module is in DLL
volatile bool                _txRunning                  = false;      // main() is still running
volatile bool                _txExit                     = false;      // exit() is active

volatile POINT               _txMousePos                 = {-1,-1};    // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
volatile unsigned            _txMouseButtons             = 0;

volatile WNDPROC             _txAltWndProc               = NULL;       // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().

_tx_thread _txLoc            _txLoc::Cur                 = {};         // Execution point tracking and trace state, see "$" macro

volatile int                 _txErrors                   = 0;          // TX_ERROR calls sequental number
int                          _txOGLError                 = 0;          // Last OpenGL error when using tx_glGetError()
volatile long                _txSENumber                 = 0;          // SEH exceptions sequental number
volatile long                _txSEFatalNumber            = 0;          // SEH fatal exceptions sequental number
char                         _txDumpSE [_TX_BUFSIZE]     = "";         // SEH dump data area
char                         _txTraceSE[_TX_HUGEBUFSIZE] = "";         // Stack trace data area

LPTOP_LEVEL_EXCEPTION_FILTER _txPrevUEFilter             = NULL;       // Previous UnhandledExceptionFilter

jmp_buf                      _txDumpExceptionObjJmp      = {};         // Hook for _txDumpExceptionObj

const volatile uintptr_t     _txForceImport[]            = { (uintptr_t) ::TerminateProcess,              (uintptr_t) ::ExitProcess,
                                                             (uintptr_t) ::FatalExit,                     (uintptr_t) ::FatalAppExitA,
                                                             (uintptr_t) ::exit,                          (uintptr_t) Win32::_controlfp,
                                                             (uintptr_t) Win32::Polyline,                 (uintptr_t) Win32::PolyBezier,
                                                             (uintptr_t) Win32::RoundRect,                (uintptr_t) Win32::RemoveVectoredExceptionHandler,
                                                             (uintptr_t) Win32::PlgBlt,                   (uintptr_t) Win32::RtlCaptureStackBackTrace,
                                                             (uintptr_t) Win32::SymInitialize,            (uintptr_t) Win32::MinGW::SymInitialize,
                                                             (uintptr_t) Win32::SymSetOptions,            (uintptr_t) Win32::MinGW::SymSetOptions,
                                                             (uintptr_t) Win32::SymGetLineFromAddr64,     (uintptr_t) Win32::MinGW::SymGetLineFromAddr64,
                                                             (uintptr_t) Win32::SymFromAddr,              (uintptr_t) Win32::MinGW::SymFromAddr,
                                                             (uintptr_t) Win32::SymCleanup,               (uintptr_t) Win32::MinGW::SymCleanup,
                                                             (uintptr_t) Win32::SymGetModuleBase64,       (uintptr_t) Win32::MinGW::SymGetModuleBase64,
                                                             (uintptr_t) Win32::SymFunctionTableAccess64, (uintptr_t) Win32::MinGW::SymFunctionTableAccess64,
                                                             (uintptr_t) Win32::StackWalk64,              (uintptr_t) Win32::MinGW::StackWalk64,
                                                             (uintptr_t) Win32::StrStrIA,                 (uintptr_t) Win32::Wow64GetThreadContext };

volatile const unsigned      _txCanaryLast               = 0x5E2E2E5E; // Another very system value

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib engine init/check/cleanup
//! @name    Èíèöèàëèçàöèÿ/ïðîâåðêà/çàâåðøåíèå TXLib
//=================================================================================================================
//! @{

//-----------------------------------------------------------------------------------------------------------------
//{          Early initialization
//-----------------------------------------------------------------------------------------------------------------

int _txInitialize()
    {
    if (_txInitialized) return 1;
    _txInitialized = 1;

    #if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)  // See http://msdn.microsoft.com/en-us/library/w2fhc9a3%28v=vs.90%29.aspx
    _CrtSetBreakAlloc (_TX_ALLOC_BREAK);                 // and http://support.microsoft.com/ru-ru/kb/151585
    #endif

    #if defined (_TX_ALLOW_TRACE)
    _txLocLvlSet (1);
    #endif

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
                                     "compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

    _txMainThreadId = GetCurrentThreadId();
    _txMainThread   = OpenThread (THREAD_ALL_ACCESS, false, _txMainThreadId);

$3  _txIsDll = _txInDll();

$   if (!_txIsDll)
        {
$       _txConsole = ! FindAtom ("_txConsole");
$       (void)          AddAtom ("_txConsole");
        }

$   if (_txConsole)
        {
$       _txCheckSourceCP (_TX_CODEPAGE, true);

$       unsigned long stackSize = _TX_STACKSIZE;
$       _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$       _txOnSignal();

$       if (!*_txLogName)
            {$ _tx_snprintf_s (_txLogName, sizeof (_txLogName) - 1, "%s.log", txGetModuleFileName()); }

$       if (!_txIsDll)
            {
$           _TX_CALL  (Win32::AddVectoredExceptionHandler, (1, (PVECTORED_EXCEPTION_HANDLER)  _txVectoredExceptionHandler));
$           _txPrevUEFilter = SetUnhandledExceptionFilter  (   (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter);
            }

$       ::std::set_terminate             (_txOnTerminate);
$       ::std::set_new_handler           (_txOnNewHandlerAnsi);
$       _TX_CALL (Win32::set_unexpected, (_txOnUnexpected));

        #if defined (_CLANG_VER) && !defined (_MSC_VER)
$       ::std::__libcpp_debug_function = _txLibCppDebugFunction;
        #endif

$       SetConsoleCtrlHandler (_txOnConsoleCtrlEvent, true);

$       SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);

        #if defined (_MSC_VER)

$       _set_printf_count_output (1);

$       _set_new_handler (_txOnNewHandler);
$       _set_new_mode (1);

        #if !defined (_CLANG_VER)

$       _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$       _CrtSetAllocHook (_txOnAllocHook);

$       unsigned mode = _CRTDBG_MODE_FILE;
$       if (_CrtSetReportHook2 (_CRT_RPTHOOK_INSTALL, (_CRT_REPORT_HOOK) _txOnErrorReport) > 0) mode = 0;

$       _CrtSetReportMode (_CRT_WARN,   _CRTDBG_MODE_DEBUG | mode);
$       _CrtSetReportMode (_CRT_ERROR,  _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportFile (_CRT_WARN,   _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ERROR,  _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);

        #endif

$       _set_abort_behavior (_WRITE_ABORT_MSG, _WRITE_ABORT_MSG);
$       _set_abort_behavior (0,                _CALL_REPORTFAULT);

$       _RTC_SetErrorFunc              (_txOnRTCFailure);
$       _set_purecall_handler          (_txOnPureCall);
$       _set_invalid_parameter_handler (_txOnInvalidParam);

        #endif

        #if defined (__STDC_LIB_EXT1__)
$       ::std::set_constraint_handler_s (_txOnSecurityErrorAnsi);
        #endif

        #if !defined (__CYGWIN__) && defined (_GCC_VER) && (_GCC_VER >= 530) && !defined (i386)
$       __setusermatherr (_txOnMatherr);
        #endif

        #if !defined (__CYGWIN__)
$       _set_error_mode (_OUT_TO_MSGBOX | _OUT_TO_STDERR);
        #endif

$       HWND console = _txConsole_Attach();
$       SetWindowTextA (console, txGetModuleFileName (false));
        }

$   InitializeCriticalSection (&_txCanvas_LockBackBuf);

$   _txSetProcAddress ("ExitProcess",                 (uintptr_t) _txOnExitProcess,                 "KERNEL32.DLL");
$   _txSetProcAddress ("TerminateProcess",            (uintptr_t) _txOnTerminateProcess,            "KERNEL32.DLL");
$   _txSetProcAddress ("FatalExit",                   (uintptr_t) _txOnFatalExit,                   "KERNEL32.DLL");
$   _txSetProcAddress ("FatalAppExitA",               (uintptr_t) _txOnFatalAppExitA,               "KERNEL32.DLL");
$   _txSetProcAddress ("UnhandledExceptionFilter",    (uintptr_t) _txUnhandledExceptionFilter,      "KERNEL32.DLL", true);
$   _txSetProcAddress ("SetUnhandledExceptionFilter", (uintptr_t) _txOnSetUnhandledExceptionFilter, "KERNEL32.DLL");
$   _txSetProcAddress ("exit",                        (uintptr_t) _txOnExit);
$   _txSetProcAddress ("_cexit",                      (uintptr_t) _txOnCExit);

$   atexit (_txCleanup);

$   if (_txConsole)
        {
$       txSetConsoleAttr (FOREGROUND_LIGHTGRAY);

$       tx_fpreset();

$       srand ((unsigned) time (NULL));

$       SetLastError (0);
$       errno = 0;

        #if !defined (__CYGWIN__)
$       _doserrno = 0;
        #endif
        }

$   HDC dc = Win32::CreateCompatibleDC (NULL); dc asserted;
$   _txStockBitmap = (HBITMAP) Win32::SelectObject (dc, Win32::CreateCompatibleBitmap (dc, 1, 1)); _txStockBitmap asserted;
$   Win32::DeleteObject (Win32::SelectObject (dc, _txStockBitmap)) asserted;
$   Win32::DeleteDC (dc) asserted;

$   return 1;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCheckSourceCP (int needCP /*= _TX_CODEPAGE*/, bool verbose /*= true*/)
    {
$3  const char* sCodePage = NULL;
$   int codePage = 0;

$   switch (((unsigned const char*) "À") [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }

$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please

$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }

$   return (codePage == needCP);
    }

//-----------------------------------------------------------------------------------------------------------------

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;

    static char dllPaths [2][MAX_PATH] = {"", ""};

    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";

        // dllPaths[0] is relative to the TX Setup directory stored in the Registry

        char* path = dllPaths[0];

        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);

        // dllPaths[1] is relative to TXib.h file used in compilation

        path = dllPaths[1];

        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }

        if (char* dir = strrchr (path, '\\')) *dir = 0;

        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }

    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);

    if (arch)
        {
        assert (arch >= dllFileName);

        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));

        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }

    HMODULE   dll = GetModuleHandle (dllFileName);

    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);

    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);

        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);

        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }

    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);

    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;

    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);

    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè
#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
        //---------------------------------------------------------------------------------------------------------
        };
 
    //-------------------------------------------------------------------------------------------------------------
    // Óáèðàåì äåôàéíû, ÷òîáû ïîòîì íå ìåøàëè.
    // Îò ýòîãî îíè ïîëó÷àþòñÿ "ëîêàëüíîãî äåéñòâèÿ", êàê áóäòî ó íèõ áûëà áû îáëàñòü âèäèìîñòè -- ôóíêöèÿ. Íà ñàìîì    // äåëå ýòî ñäåëàíî âðó÷íóþ ÷åðåç #undef. ×òîáû ïîä÷åðêíóòü èõ ëîêàëüíóþ ïðèðîäó, ó íèõ èìåíà çàêàí÷èâàþòñÿ íà _.
    // Òàêèå äåôàéíû ïîòîì íå ïåðåêîñÿ÷àò âåñü êîä ïîñëå òîãî êàê, ôàêòè÷åñêè, ñòàëè óæå íå íóæíû.
    //-------------------------------------------------------------------------------------------------------------

    #undef ID_TEXT_
    #undef ID_INPUT_

    //-------------------------------------------------------------------------------------------------------------
    // Ýòî ñòàòè÷åñêèé îáúåêò, ïîòîìó ÷òî ñòðîêà â íåì äîëæíà æèòü ïîñëå çàâåðøåíèÿ ôóíêöèè.
    //-------------------------------------------------------------------------------------------------------------

    static inputDlg dlg;

    //-------------------------------------------------------------------------------------------------------------
    // Ïåðåäàåì layout è çàïóñêàåì îêíî äèàëîãà
    //-------------------------------------------------------------------------------------------------------------

    dlg.dialogBox (layout);

    //-------------------------------------------------------------------------------------------------------------
    // Âîçâðàùàåì àäðåñ ñòðîêè èç ñòàòè÷åñêîãî îáúåêòà. Òàê ìîæíî äåëàòü, ïîòîìó ÷òî ñòàòè÷åñêèé îáúåêò íå óìðåò
    // ïðè âûõîäå èç ôóíêöèè è ñòðîêà â íåì, ñîîòâåòñòâåííî, òîæå. Àäðåñ íåñòàòè÷åñêèõ ïåðåìåííûõ ïåðåäàâàòü
    // ñèíòàêñè÷åñêè ìîæíî, íî âåäåò ê ñåðüåçíûì îøèáêàì.
    //-------------------------------------------------------------------------------------------------------------

    return dlg.str;
    }

//! @}
//}
//=================================================================================================================

//}
//=================================================================================================================

//=================================================================================================================
//{          TXLIB IMPLEMENTATION
//           Ðåàëèçàöèÿ ôóíêöèé áèáëèîòåêè
//=================================================================================================================
//! @cond INTERNAL

//=================================================================================================================
//{          DLL functions import, missing types definitions
//! @name    Èìïîðò âíåøíèõ áèáëèîòåê, îïðåäåëåíèå íåäîñòàþùèõ òèïîâ
//=================================================================================================================
//! @{

namespace Win32 {

//-----------------------------------------------------------------------------------------------------------------
//{ Some of structs, consts and interfaces aren't defined in MinGW some early headers.
//  Copied from Windows SDK 7.0a.
//-----------------------------------------------------------------------------------------------------------------

#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                             0x01
#endif

#ifndef SMTO_ERRORONEXIT
#define SMTO_ERRORONEXIT                         0x0020
#endif

#ifndef NT_CONSOLE_PROPS_SIG
#define NT_CONSOLE_PROPS_SIG                     0xA0000002
#endif

#ifndef NIIF_INFO
#define NIIF_INFO                                0x00000001
#define NIIF_WARNING                             0x00000002
#define NIIF_ERROR                               0x00000003
#endif

#ifndef NIF_INFO
#define NIF_STATE                                0x00000008
#define NIF_INFO                                 0x00000010
#endif

#ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
#define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS   0x00000004
#endif

#ifndef SYMOPT_CASE_INSENSITIVE
#define SYMOPT_CASE_INSENSITIVE                  0x00000001
#define SYMOPT_UNDNAME                           0x00000002
#define SYMOPT_DEFERRED_LOADS                    0x00000004
#define SYMOPT_NO_CPP                            0x00000008
#define SYMOPT_LOAD_LINES                        0x00000010
#define SYMOPT_OMAP_FIND_NEAREST                 0x00000020
#define SYMOPT_LOAD_ANYTHING                     0x00000040
#define SYMOPT_IGNORE_CVREC                      0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS              0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS              0x00000200
#define SYMOPT_EXACT_SYMBOLS                     0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS            0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH                 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES             0x00002000
#define SYMOPT_PUBLICS_ONLY                      0x00004000
#define SYMOPT_NO_PUBLICS                        0x00008000
#define SYMOPT_AUTO_PUBLICS                      0x00010000
#define SYMOPT_NO_IMAGE_SEARCH                   0x00020000
#define SYMOPT_SECURE                            0x00040000
#define SYMOPT_NO_PROMPTS                        0x00080000
#define SYMOPT_ALLOW_ZERO_ADDRESS                0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT         0x02000000
#define SYMOPT_FAVOR_COMPRESSED                  0x00800000
#define SYMOPT_FLAT_DIRECTORY                    0x00400000
#define SYMOPT_IGNORE_IMAGEDIR                   0x00200000
#define SYMOPT_OVERWRITE                         0x00100000
#define SYMOPT_DEBUG                             0x80000000
#endif

// SEH exception codes. For GCC, see http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 64-66.

#ifndef STATUS_POSSIBLE_DEADLOCK
#define STATUS_POSSIBLE_DEADLOCK                 0xC0000194
#endif

#ifndef STATUS_FLOAT_MULTIPLE_FAULTS
#define STATUS_FLOAT_MULTIPLE_FAULTS             0xC00002B4
#endif

#ifndef STATUS_STACK_BUFFER_OVERRUN
#define STATUS_STACK_BUFFER_OVERRUN              0xC0000409
#endif

#ifndef STATUS_ASSERTION_FAILURE
#define STATUS_ASSERTION_FAILURE                 0xC0000420
#endif

#ifndef STATUS_WX86_BREAKPOINT
#define STATUS_WX86_BREAKPOINT                   0x4000001F
#endif

#ifndef DBG_PRINTEXCEPTION_C
#define DBG_PRINTEXCEPTION_C                     0x40010006  // OutputDebugStringA() call
#endif

#ifndef DBG_PRINTEXCEPTION_WIDE_C
#define DBG_PRINTEXCEPTION_WIDE_C                0x4001000A  // OutputDebugStringW() call
#endif

#ifndef DBG_THREAD_NAME
#define DBG_THREAD_NAME                          0x406D1388
#endif

#define EXCEPTION_CPP_MSC                        0xE06D7363  // '?msc'
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1       0x19930520  // '?msc' version magic, see ehdata.h
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2       0x19930521  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3       0x19930522  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1  0x01994000  // '?msc' version magic

#define EXCEPTION_CPP_GCC                        0x20474343  // ' GCC'
#define EXCEPTION_CPP_GCC_UNWIND                 0x21474343  // '!GCC'
#define EXCEPTION_CPP_GCC_FORCED                 0x22474343  // '"GCC'

#define EXCEPTION_CLR_FAILURE                    0xE0434f4D  // 'àCOM'

#define EXCEPTION_CPP_BORLAND_BUILDER            0x0EEDFAE6  // Should never occur here
#define EXCEPTION_CPP_BORLAND_DELPHI             0x0EEDFADE  // Should never occur here

#pragma pack (push, 1)

struct CONSOLE_CURSOR_INFO
    {
    DWORD dwSize;
    BOOL bVisible;
    };

struct CONSOLE_FONT_INFO
    {
    DWORD nFont;
    COORD dwFontSize;
    };

struct CONSOLE_FONT_INFOEX
    {
    ULONG cbSize;
    DWORD nFont;
    COORD dwFontSize;
    UINT  FontFamily;
    UINT  FontWeight;
    WCHAR FaceName[LF_FACESIZE];
    };

struct DATABLOCK_HEADER
    {
    DWORD cbSize;
    DWORD dwSignature;
    };

struct NT_CONSOLE_PROPS
    {
    DATABLOCK_HEADER dbh;

    WORD  wFillAttribute;
    WORD  wPopupFillAttribute;
    COORD dwScreenBufferSize;
    COORD dwWindowSize;
    COORD dwWindowOrigin;
    DWORD nFont;
    DWORD nInputBufferSize;
    COORD dwFontSize;
    UINT  uFontFamily;
    UINT  uFontWeight;
    WCHAR FaceName[LF_FACESIZE];
    UINT  uCursorSize;
    BOOL  bFullScreen;
    BOOL  bQuickEdit;
    BOOL  bInsertMode;
    BOOL  bAutoPosition;
    UINT  uHistoryBufferSize;
    UINT  uNumberOfHistoryBuffers;
    BOOL  bHistoryNoDup;

    COLORREF ColorTable[16];
    };

#pragma pack (pop)

#undef  INTERFACE
#define INTERFACE IShellLinkDataList

DECLARE_INTERFACE_ (IShellLinkDataList, IUnknown)
    {
    // *** IUnknown methods ***
    STDMETHOD (QueryInterface)  (THIS_ REFIID iid, void** value)    _tx_override PURE;
    STDMETHOD_(ULONG, AddRef)   (THIS)                              _tx_override PURE;
    STDMETHOD_(ULONG, Release)  (THIS)                              _tx_override PURE;

    // *** IShellLinkDataList methods ***
    STDMETHOD (AddDataBlock)    (THIS_ void* dataBlock)             PURE;
    STDMETHOD (CopyDataBlock)   (THIS_ DWORD sig, void** dataBlock) PURE;
    STDMETHOD (RemoveDataBlock) (THIS_ DWORD sig)                   PURE;
    STDMETHOD (GetFlags)        (THIS_ DWORD* flags)                PURE;
    STDMETHOD (SetFlags)        (THIS_ DWORD  flags)                PURE;

    protected:
    virtual ~IShellLinkDataList();
    };

const GUID IID_IShellLink         = {0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID IID_IShellLinkDataList = {0x45e2b4ae, 0xb1c3, 0x11d0, {0xb9,0x2f,0x00,0xa0,0xc9,0x03,0x12,0xe1}};
const GUID IID_IPersistFile       = {0x0000010b, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};

const GUID CLSID_SpVoice          = {0x96749377, 0x3391, 0x11d2, {0x9e,0xe3,0x00,0xc0,0x4f,0x79,0x73,0x96}};
const GUID IID_ISpVoice           = {0x6c44df74, 0x72b9, 0x4992, {0xa1,0xec,0xef,0x99,0x6e,0x04,0x22,0xd4}};

#undef  INTERFACE

typedef DWORD     NTSTATUS;
typedef ULONG_PTR KAFFINITY;
typedef LONG      KPRIORITY;

struct UNICODE_STRING
    {
    USHORT Length;
    USHORT MaximumLength;
    WCHAR* Buffer;
    };

struct RTL_USER_PROCESS_PARAMETERS
    {
    BYTE  Reserved1[16];
    void* Reserved2[10];
    UNICODE_STRING ImagePathName;
    UNICODE_STRING CommandLine;
    };

struct PEB
    {
    BYTE  Reserved1[2];
    BYTE  BeingDebugged;
    BYTE  Reserved2[1];
    void* Reserved3[2];
    void* Ldr;
    RTL_USER_PROCESS_PARAMETERS* ProcessParameters;
    void* Reserved4[3];
    void* AtlThunkSListPtr;
    void* Reserved5;
    ULONG Reserved6;
    void* Reserved7;
    ULONG Reserved8;
    ULONG AtlThunkSListPtr32;
    void* Reserved9[45];
    BYTE  Reserved10[96];
    void* PostProcessInitRoutine;
    BYTE  Reserved11[128];
    void* Reserved12[1];
    ULONG SessionId;
    };

struct PROCESS_BASIC_INFORMATION
    {
    NTSTATUS  ExitStatus;
    PEB*      PebBaseAddress;
    KAFFINITY AffinityMask;
    KPRIORITY BasePriority;
    ULONG_PTR UniqueProcessId;
    ULONG_PTR InheritedFromUniqueProcessId;
    };

enum ADDRESS_MODE
    {
    AddrMode1616,
    AddrMode1632,
    AddrModeReal,
    AddrModeFlat
    };

struct ADDRESS64
    {
    DWORD64      Offset;
    WORD         Segment;
    ADDRESS_MODE Mode;
    };

struct KDHELP64
    {
    DWORD64 Thread;
    DWORD   ThCallbackStack;
    DWORD   ThCallbackBStore;
    DWORD   NextCallback;
    DWORD   FramePointer;
    DWORD64 KiCallUserMode;
    DWORD64 KeUserCallbackDispatcher;
    DWORD64 SystemRangeStart;
    DWORD64 KiUserExceptionDispatcher;
    DWORD64 StackBase;
    DWORD64 StackLimit;
    DWORD64 Reserved[5];
    };

struct STACKFRAME64
    {
    ADDRESS64 AddrPC;
    ADDRESS64 AddrReturn;
    ADDRESS64 AddrFrame;
    ADDRESS64 AddrStack;
    ADDRESS64 AddrBStore;
    PVOID     FuncTableEntry;
    DWORD64   Params[4];
    BOOL      Far;
    BOOL      Virtual;
    DWORD64   Reserved[3];
    KDHELP64  KdHelp;
    };

struct WOW64_FLOATING_SAVE_AREA
    {
    DWORD ControlWord;
    DWORD StatusWord;
    DWORD TagWord;
    DWORD ErrorOffset;
    DWORD ErrorSelector;
    DWORD DataOffset;
    DWORD DataSelector;
    BYTE  RegisterArea[80];
    DWORD Cr0NpxState;
    };

#pragma pack (push, 4)

struct WOW64_CONTEXT
    {
    DWORD ContextFlags;

    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;

    WOW64_FLOATING_SAVE_AREA FloatSave;

    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;

    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;

    DWORD Ebp;
    DWORD Eip;
    DWORD SegCs;
    DWORD EFlags;
    DWORD Esp;
    DWORD SegSs;

    BYTE  ExtendedRegisters[512];
    };

#pragma pack (pop)

struct SYMBOL_INFO
    {
    ULONG   SizeOfStruct;
    ULONG   TypeIndex;
    ULONG64 Reserved[2];
    ULONG   info;
    ULONG   Size;
    ULONG64 ModBase;
    ULONG   Flags;
    ULONG64 Value;
    ULONG64 Address;
    ULONG   Register;
    ULONG   Scope;
    ULONG   Tag;
    ULONG   NameLen;
    ULONG   MaxNameLen;
    CHAR    Name[1];
    };

struct IMAGEHLP_LINE64
    {
    DWORD   SizeOfStruct;
    PVOID   Key;
    DWORD   LineNumber;
    PCHAR   FileName;
    DWORD64 Address;
    };

typedef bool    (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)   (HANDLE process, DWORD64 baseAddress, void* buffer, DWORD size, DWORD* bytesRead);
typedef void*   (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64) (HANDLE process, DWORD64 baseAddress);
typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)       (HANDLE process, DWORD64 address);
typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)     (HANDLE process, HANDLE thread, ADDRESS64* address);

typedef void (*unexpected_handler)();

#pragma pack (push, 4)

struct MINIDUMP_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    };

struct MINIDUMP_THREAD_EX_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    ULONG64  BackingStoreBase;
    ULONG64  BackingStoreEnd;
    };

struct MINIDUMP_MODULE_CALLBACK
    {
    wchar_t* FullPath;
    ULONG64  BaseOfImage;
    ULONG    SizeOfImage;
    ULONG    CheckSum;
    ULONG    TimeDateStamp;
    VS_FIXEDFILEINFO VersionInfo;
    void*    CvRecord;
    ULONG    SizeOfCvRecord;
    PVOID    MiscRecord;
    ULONG    SizeOfMiscRecord;
    };

struct MINIDUMP_INCLUDE_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    };

struct MINIDUMP_INCLUDE_MODULE_CALLBACK
    {
    ULONG64  BaseOfImage;
    };

struct MINIDUMP_MEMORY_INFO
    {
    ULONG64  BaseAddress;
    ULONG64  AllocationBase;
    ULONG32  AllocationProtect;
    ULONG32  __alignment1;
    ULONG64  RegionSize;
    ULONG32  State;
    ULONG32  Protect;
    ULONG32  Type;
    ULONG32  __alignment2;
    };

struct MINIDUMP_USER_STREAM
    {
    ULONG32  Type;
    ULONG    BufferSize;
    PVOID    Buffer;
    };

struct MINIDUMP_USER_STREAM_INFORMATION
    {
    ULONG                 UserStreamCount;
    MINIDUMP_USER_STREAM* UserStreamArray;
    };

struct MINIDUMP_CALLBACK_INPUT
    {
    ULONG    ProcessId;
    HANDLE   ProcessHandle;
    ULONG    CallbackType;

    union
        {
        MINIDUMP_THREAD_CALLBACK         Thread;
        MINIDUMP_THREAD_EX_CALLBACK      ThreadEx;
        MINIDUMP_MODULE_CALLBACK         Module;
        MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
        MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
        };
    };

struct MINIDUMP_CALLBACK_OUTPUT
    {
    union
        {
        ULONG ModuleWriteFlags;
        ULONG ThreadWriteFlags;
        ULONG SecondaryFlags;

        struct
            {
            ULONG64  MemoryBase;
            ULONG    MemorySize;
            };

        struct
            {
            unsigned CheckCancel;
            unsigned Cancel;
            };

        HANDLE Handle;
        };

    struct
        {
        MINIDUMP_MEMORY_INFO VmRegion;
        unsigned             Continue;
        };

    HRESULT Status;
    };

struct MINIDUMP_EXCEPTION_INFORMATION
    {
    DWORD               ThreadId;
    EXCEPTION_POINTERS* ExceptionPointers;
    unsigned            ClientPointers;
    };

typedef int (WINAPI* MINIDUMP_CALLBACK_ROUTINE) (void* param, MINIDUMP_CALLBACK_INPUT* input, MINIDUMP_CALLBACK_OUTPUT* output);

struct MINIDUMP_CALLBACK_INFORMATION
    {
    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
    void*                     CallbackParam;
    };

enum MINIDUMP_TYPE
    {
    MiniDumpNormal                         = 0x00000000,
    MiniDumpWithDataSegs                   = 0x00000001,
    MiniDumpWithFullMemory                 = 0x00000002,
    MiniDumpWithHandleData                 = 0x00000004,
    MiniDumpFilterMemory                   = 0x00000008,
    MiniDumpScanMemory                     = 0x00000010,
    MiniDumpWithUnloadedModules            = 0x00000020,
    MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
    MiniDumpFilterModulePaths              = 0x00000080,
    MiniDumpWithProcessThreadData          = 0x00000100,
    MiniDumpWithPrivateReadWriteMemory     = 0x00000200,
    MiniDumpWithoutOptionalData            = 0x00000400,
    MiniDumpWithFullMemoryInfo             = 0x00000800,
    MiniDumpWithThreadInfo                 = 0x00001000,
    MiniDumpWithCodeSegs                   = 0x00002000,
    MiniDumpWithoutAuxiliaryState          = 0x00004000,
    MiniDumpWithFullAuxiliaryState         = 0x00008000,
    MiniDumpWithPrivateWriteCopyMemory     = 0x00010000,
    MiniDumpIgnoreInaccessibleMemory       = 0x00020000,
    MiniDumpWithTokenInformation           = 0x00040000
    };

#pragma pack (pop)

#define FOREGROUND_BLACK         ( 0                                                         )
#define FOREGROUND_CYAN          ( FOREGROUND_BLUE       | FOREGROUND_GREEN                  )
#define FOREGROUND_MAGENTA       ( FOREGROUND_BLUE       | FOREGROUND_RED                    )
#define FOREGROUND_DARKYELLOW    ( FOREGROUND_GREEN      | FOREGROUND_RED                    )
#define FOREGROUND_LIGHTGRAY     ( FOREGROUND_BLUE       | FOREGROUND_GREEN | FOREGROUND_RED )
#define FOREGROUND_DARKGRAY      (                         FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTBLUE     ( FOREGROUND_BLUE       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTGREEN    ( FOREGROUND_GREEN      | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTCYAN     ( FOREGROUND_CYAN       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTRED      ( FOREGROUND_RED        | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTMAGENTA  ( FOREGROUND_MAGENTA    | FOREGROUND_INTENSITY              )
#define FOREGROUND_YELLOW        ( FOREGROUND_DARKYELLOW | FOREGROUND_INTENSITY              )
#define FOREGROUND_WHITE         ( FOREGROUND_LIGHTGRAY  | FOREGROUND_INTENSITY              )

#define BACKGROUND_BLACK         ( 0                                                         )
#define BACKGROUND_CYAN          ( BACKGROUND_BLUE       | BACKGROUND_GREEN                  )
#define BACKGROUND_MAGENTA       ( BACKGROUND_BLUE       | BACKGROUND_RED                    )
#define BACKGROUND_DARKYELLOW    ( BACKGROUND_GREEN      | BACKGROUND_RED                    )
#define BACKGROUND_GRAY          ( BACKGROUND_BLUE       | BACKGROUND_GREEN | BACKGROUND_RED )
#define BACKGROUND_DARKGRAY      (                         BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTBLUE     ( BACKGROUND_BLUE       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTGREEN    ( BACKGROUND_GREEN      | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTCYAN     ( BACKGROUND_CYAN       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTRED      ( BACKGROUND_RED        | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTMAGENTA  ( BACKGROUND_MAGENTA    | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTYELLOW   ( BACKGROUND_DARKYELLOW | BACKGROUND_INTENSITY              )
#define BACKGROUND_WHITE         ( BACKGROUND_DARKGRAY   | BACKGROUND_INTENSITY              )

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ There are copies of MSVC compiler built-in predefined definitions, which are wrong in 64-bit mode.
//  So we have to override them. See: http://stackoverflow.com/questions/39113168
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)
                                                    //  MS ABI C++ Exception Layout
namespace Win32 {                                   //  ---------------------------
                                                    //
#pragma pack (push, 4)                              //   EXCEPTION_RECORD:
                                                    //  +==================================================+
struct ThrowInfo                                    //  |...                                               |
    {                                               //  |NumberParameters:        3, 4 or more             |
    __int32 attributes;                             //  |ExceptionInformation[0]: MS signature 0x19930520  |
    __int32 pmfnUnwind;                             //  |ExceptionInformation[1]: object* thrown           |
    __int32 pForwardCompat;                         //  |ExceptionInformation[2]: ThrowInfo* --------------+---+
    __int32 pCatchableTypeArray;                    //  |ExceptionInformation[3]: ImageBase (if params > 3)|   |
    };                                              //  +==================================================+   |
                                                    //                                                         |
struct CatchableTypeArray                           //        ThrowInfo:                                       |
    {                                               //        +======================================+ <-------+
    __int32 nCatchableTypes;                        //        |   ...                                |
    __int32 arrayOfCatchableTypes[];                //  +-----+-- pCatchableTypeArray (ptr/RVA)      |
    };                                              //  |     +======================================+
                                                    //  |
struct CatchableType                                //  |     CatchableTypeArray:
    {                                               //  +---> +======================================+
    __int32 properties;                             //        |   ...                                |
    __int32 pType;                                  //  +-----+-- arrayOfCatchableTypes[0] (ptr/RVA) |
    __int32 thisDisplacement[3]; // struct _PMD     //  |     +======================================+
    __int32 sizeOrOffset;                           //  |
    __int32 copyFunction;                           //  |     CatchableType:
    };                                              //  +---> +====================+
                                                    //        | ...                |        std::type_info:
#pragma pack (pop)                                  //        | pType (ptr/RVA) ---+------> +==================+
                                                    //        | ...                |        |type_info data    |
} // namespace Win32                                //        +====================+        |...               |
                                                    //                                      +==================+
#endif

// Similar to __CxxDetectRethrow(), see C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\crtsrc\vcruntime\frame.cpp:

#define _TX_MSC__CXX_DETECT_RETHROW( exc )                                     \
    (                                                                          \
    (exc)                                          &&                          \
    (exc) -> ExceptionCode    == EXCEPTION_CPP_MSC &&                          \
    (exc) -> NumberParameters >= 3                 &&                          \
                                                                               \
    ((exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3) && \
                                                                               \
    (exc) -> ExceptionInformation[2] == 0                                      \
    )

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ The corresponding structures for GCC
//
//  From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/unwind-cxx.h
//  See:  http://mentorembedded.github.io/cxx-abi/abi-eh.html#cxx-abi
//-----------------------------------------------------------------------------------------------------------------

#if defined (_GCC_VER)
                                                    // GCC ABI C++ Exception layout. A/B are ExceptionInformation[0].
namespace ABI {                                     // --------------------------------------------------------------
                                                    //
struct __cxa_exception                              // Case A: "_Unwind_Exception* A" is undependent exception:
    {                                               // --------------------------------------------------------
    union {                                         //
        struct                                      //           __cxa_exception:           std::type_info:
            {                                       //       -*--+====================+     +==================+
            ::std::type_info* exceptionType;        //        ^  |exceptionType* -----+---->|type_info data    |
            void (*exceptionDestructor)(void*);     //        |  |...                 |     |...               |
            };                                      //       -1  |                    |     +==================+
        struct                                      //        |  |                    |
            {                                       // A >----|--+--------------------+
            __cxa_exception*  primaryException;     //     |  |  |unwindHeader        |
            void (*padding)();                      //    +1  |  |                    |
            };                                      //     |  |  |                    |
        };                                          //     V  |  |                    |
                                                    //    -*---  +====================+
    std::unexpected_handler   unexpectedHandler;    //           |object              |
    std::terminate_handler    terminateHandler;     //           +--------------------+
                                                    //
    __cxa_exception*          nextException;        // Case B: "_Unwind_Exception* B" is dependent exception
    int                       handlerCount;         // (unwindHeader.exception_class & 1 != 0):
    int                       handlerSwitchValue;   // -----------------------------------------------------
    const unsigned char*      actionRecord;         //
    const unsigned char*      languageSpecificData; //           __cxa_exception:               __cxa_exception:
    void*                     catchTemp;            //       -*--+====================+     -*--+=================+
    void*                     adjustedPtr;          //        ^  |primaryException* --+--    ^  |exceptionType*   |
                                                    //        |  |...                 |  \   |  |...              |
    _Unwind_Exception         unwindHeader;         //       -1  |                    |  |   |  |                 |
    };                                              //        |  |                    |  |   |  |                 |
                                                    // B >----|--+--------------------+  |  -1  +-----------------+
struct __cxa_eh_globals                             //     |  |  |unwindHeader        |  |   |  |unwindHeader     |
    {                                               //    +1  |  |                    |  |   |  |                 |
    __cxa_exception* caughtExceptions;              //     |  |  |                    |  |   |  |                 |
    unsigned int     uncaughtExceptions;            //     V  |  |                    |  \   |  |                 |
    };                                              //    -*---  +====================+   -->*--+=================+
                                                    //           |...                 |         |object           |
} // namespace ABI                                  //           .                    .         |                 |
                                                    //                                          +-----------------+

extern "C" ABI::__cxa_eh_globals* __cxa_get_globals();

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ Hand-made IAT.
//  Some IDEs don't link with these libs by default in console projects, so do sunrise by hand. :(
//-----------------------------------------------------------------------------------------------------------------

// Hand-made DLLIMPORT helpers

#define _TX_DLLIMPORT(     lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, true)

#define _TX_DLLIMPORT_OPT( lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, false)

#define _TX_DLLIMPORT_CRT( lib, retval, name, params ) \
     retval (      * name) params = (retval (      *) params) _txDllImport (lib ".dll", #name, false)

typedef void (*_tx_FARPROC)();

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required = true);

//-----------------------------------------------------------------------------------------------------------------

namespace Win32 {

_TX_DLLIMPORT     ("GDI32",    HDC,      CreateCompatibleDC,            (HDC dc));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateCompatibleBitmap,        (HDC dc, int width, int height));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetStockObject,                (int object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  SelectObject,                  (HDC dc, HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetCurrentObject,              (HDC dc, unsigned objectType));
_TX_DLLIMPORT     ("GDI32",    int,      GetObjectA,                    (HGDIOBJ obj, int bufsize, void* buffer));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GetObjectType,                 (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteDC,                      (HDC dc));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteObject,                  (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetTextColor,                  (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetBkColor,                    (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    int,      SetBkMode,                     (HDC dc, int bkMode));
_TX_DLLIMPORT     ("GDI32",    HFONT,    CreateFontA,                   (int height, int width, int escapement, int orientation,
                                                                         int weight, DWORD italic, DWORD underline, DWORD strikeout,
                                                                         DWORD charSet, DWORD outputPrec, DWORD clipPrec,
                                                                         DWORD quality, DWORD pitchAndFamily, const char face[]));
_TX_DLLIMPORT     ("GDI32",    int,      EnumFontFamiliesExA,           (HDC dc, LPLOGFONT logFont, FONTENUMPROC enumProc,
                                                                         LPARAM lParam, DWORD reserved));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetPixel,                      (HDC dc, int x, int y, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, GetPixel,                      (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    HPEN,     CreatePen,                     (int penStyle, int width, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    HBRUSH,   CreateSolidBrush,              (COLORREF color));
_TX_DLLIMPORT     ("GDI32",    bool,     MoveToEx,                      (HDC dc, int x, int y, POINT* point));
_TX_DLLIMPORT     ("GDI32",    bool,     LineTo,                        (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    bool,     Polygon,                       (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Polyline,                      (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     PolyBezier,                    (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Rectangle,                     (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     RoundRect,                     (HDC dc, int x0, int y0, int x1, int y1, int sizeX, int sizeY));
_TX_DLLIMPORT     ("GDI32",    bool,     Ellipse,                       (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     Arc,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Pie,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Chord,                         (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     TextOutA,                      (HDC dc, int x, int y, const char string[], int length));
_TX_DLLIMPORT     ("GDI32",    UINT,     SetTextAlign,                  (HDC dc, unsigned mode));
_TX_DLLIMPORT     ("GDI32",    bool,     GetTextExtentPoint32A,         (HDC dc, const char string[], int length, SIZE* size));
_TX_DLLIMPORT     ("GDI32",    bool,     ExtFloodFill,                  (HDC dc, int x, int y, COLORREF color, unsigned type));
_TX_DLLIMPORT     ("GDI32",    bool,     BitBlt,                        (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src,  int xSrc,  int ySrc,  DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     StretchBlt,                    (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src, int xSrc, int ySrc, int wSrc, int hSrc, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     PlgBlt,                        (HDC dest, const POINT* parallelogram,
                                                                         HDC src, int xSrc, int ySrc, int width, int height,
                                                                         HBITMAP mask, int xMask, int yMask));
_TX_DLLIMPORT     ("GDI32",    int,      SetDIBitsToDevice,             (HDC dc, int xDest, int yDest, DWORD width, DWORD height,
                                                                         int xSrc, int ySrc, unsigned startLine, unsigned numLines,
                                                                         const void* data, const BITMAPINFO* info, unsigned colorUse));
_TX_DLLIMPORT     ("GDI32",    int,      GetDIBits,                     (HDC hdc, HBITMAP hbmp, unsigned uStartScan, unsigned cScanLines,
                                                                         void* lpvBits, BITMAPINFO* lpbi, unsigned usage));
_TX_DLLIMPORT     ("GDI32",    bool,     PatBlt,                        (HDC dc, int x0, int y0, int width, int height, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    int,      SetROP2,                       (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    int,      SetStretchBltMode,             (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GdiSetBatchLimit,              (DWORD limit));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateDIBSection,              (HDC dc, const BITMAPINFO* bmInfo, unsigned colorUsage, void **vBits,
                                                                         HANDLE section, DWORD offset));

_TX_DLLIMPORT     ("User32",   int,      DrawTextA,                     (HDC dc, const char text[], int length, RECT* rect, unsigned format));
_TX_DLLIMPORT     ("User32",   HANDLE,   LoadImageA,                    (HINSTANCE inst, const char name[], unsigned type,
                                                                        int sizex, int sizey, unsigned mode));
_TX_DLLIMPORT_OPT ("User32",   bool,     IsHungAppWindow,               (HWND wnd));
_TX_DLLIMPORT_OPT ("User32",   HWND,     GhostWindowFromHungWindow,     (HWND wnd));

_TX_DLLIMPORT     ("WinMM",    bool,     PlaySound,                     (const char sound[], HMODULE mod, DWORD mode));

_TX_DLLIMPORT_OPT ("MSImg32",  bool,     TransparentBlt,                (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         unsigned transparentColor));
_TX_DLLIMPORT_OPT ("MSImg32",  bool,     AlphaBlend,                    (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         BLENDFUNCTION blending));

_TX_DLLIMPORT     ("Kernel32", void,     ExitProcess,                   (unsigned retcode));
_TX_DLLIMPORT     ("Kernel32", bool,     TerminateProcess,              (HANDLE process, unsigned retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalExit,                     (int retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalAppExitA,                 (unsigned action, const char message[]));
_TX_DLLIMPORT     ("Kernel32", HWND,     GetConsoleWindow,              (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetConsoleFont,                (HANDLE con, DWORD fontIndex));
_TX_DLLIMPORT_OPT ("Kernel32", DWORD,    GetNumberOfConsoleFonts,       (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFont,         (HANDLE con, bool maxWnd, CONSOLE_FONT_INFO*   curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", void,     RtlCaptureContext,             (CONTEXT* contextRecord));
_TX_DLLIMPORT_OPT ("Kernel32", USHORT,   RtlCaptureStackBackTrace,      (DWORD framesToSkip, DWORD framesToCapture, void** backTrace, DWORD* hash));
_TX_DLLIMPORT_OPT ("Kernel32", void*,    AddVectoredExceptionHandler,   (unsigned long firstHandler, PVECTORED_EXCEPTION_HANDLER handler));
_TX_DLLIMPORT_OPT ("Kernel32", unsigned, RemoveVectoredExceptionHandler,(void* handler));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetModuleHandleEx,             (DWORD flags, const char moduleName[], HMODULE* module));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     IsWow64Process,                (HANDLE process, int* isWow64Process));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     Wow64GetThreadContext,         (HANDLE thread, WOW64_CONTEXT* context));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetThreadStackGuarantee,       (unsigned long* stackSize));

_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoInitialize,                  (void*));
_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoCreateInstance,              (REFCLSID clsId, IUnknown*, DWORD, REFIID iId, PVOID* value));
_TX_DLLIMPORT     ("OLE32",    void,     CoUninitialize,                (void));

_TX_DLLIMPORT     ("Shell32",  HINSTANCE,ShellExecuteA,                 (HWND wnd, const char operation[], const char file[],
                                                                         const char parameters[], const char directory[], int showCmd));

_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIA,                      (const char    string[], const char    search[]));
_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIW,                      (const wchar_t string[], const wchar_t search[]));

_TX_DLLIMPORT_OPT ("NTDLL",    char*,    wine_get_version,              (void));
_TX_DLLIMPORT     ("NTDLL",    NTSTATUS, NtQueryInformationProcess,     (HANDLE process, int infoClass,
                                                                         void* processInfo, unsigned long szProcessInfo, unsigned long* szReturnInfo));

_TX_DLLIMPORT_CRT ("MSVCRT",   void,     exit,                          (int retcode));
_TX_DLLIMPORT_CRT ("MSVCRT",   void,     _cexit,                        (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _fpreset,                      (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _controlfp,                    (unsigned control, unsigned mask));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthread,                  (void (__cdecl* start_address) (void*), unsigned stack_size, void* arglist));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthreadex,                (void* security, unsigned stack_size, unsigned (__stdcall* start_address) (void*),
                                                                         void *arglist, unsigned init_flag, unsigned* thread_addr));
_TX_DLLIMPORT_CRT ("MSVCRT",   char*,    __unDName,                     (char* outStr, const char* mangledName, int outStrLen,
                                                                         void* (*mallocFunc) (size_t size), void (*freeFunc) (void *pointer),
                                                                         unsigned short flags));
_TX_DLLIMPORT_CRT ("MSVCRT",   unexpected_handler, set_unexpected,      (unexpected_handler handler));

_TX_DLLIMPORT_OPT ("OpenGL32", HDC,         wglGetCurrentDC,            (void));
_TX_DLLIMPORT_OPT ("OpenGL32", unsigned,    glGetError,                 (void));
_TX_DLLIMPORT_OPT ("Glu32",    const char*, gluErrorString,             (unsigned error));

_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     MiniDumpWriteDump,             (HANDLE process, DWORD processId, HANDLE file, MINIDUMP_TYPE dumpType,
                                                                         MINIDUMP_EXCEPTION_INFORMATION*   exceptionParam,
                                                                         MINIDUMP_USER_STREAM_INFORMATION* userStreamParam,
                                                                         MINIDUMP_CALLBACK_INFORMATION*    callbackParam));

_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("DbgHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
namespace MinGW {
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("MgwHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
} // namespace MinGW

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal function prototypes, macros and constants
//  @name    Ïðîòîòèïû âíóòðåííèõ ôóíêöèé, ìàêðîñû è êîíñòàíòû
//=================================================================================================================
//! @{

const int        _TX_IDM_ABOUT                            =   40000,       // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
                 _TX_IDM_CONSOLE                          =   40001,
                 _TX_WM_CREATEWND                         =   0x7FF0,      // Ñîîáùåíèÿ äëÿ ñîçäàíèÿ/óíè÷òîæåíèÿ
                 _TX_WM_DESTROYWND                        =   0x7FF1;      // îêîí â ïîòîêå Canvas

//-----------------------------------------------------------------------------------------------------------------

int              _txInitialize();
void             _txCleanup();

HWND             _txCanvas_CreateWindow      (const SIZE* size);
inline bool      _txCanvas_OK() tx_nodiscard;

bool             _txCanvas_OnCREATE          (HWND wnd);
bool             _txCanvas_OnDESTROY         (HWND wnd);
bool             _txCanvas_OnCLOSE           (HWND);
bool             _txCanvas_OnPAINT           (HWND wnd);
bool             _txCanvas_OnKEYDOWN         (HWND wnd, WPARAM vk, LPARAM info);
bool             _txCanvas_OnCHAR            (HWND wnd, WPARAM ch, LPARAM info);
bool             _txCanvas_OnTIMER           (HWND wnd, WPARAM id);
bool             _txCanvas_OnMOUSEMOVE       (HWND wnd, WPARAM buttons, LPARAM coords);
bool             _txCanvas_OnMOUSELEAVE      (HWND wnd);
bool             _txCanvas_OnCREATEWND       (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnDESTROYWND      (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnCmdCONSOLE      (HWND wnd, WPARAM cmd);
bool             _txCanvas_OnCmdABOUT        (HWND wnd, WPARAM cmd);

unsigned WINAPI  _txCanvas_ThreadProc        (void* data);
LRESULT CALLBACK _txCanvas_WndProc           (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);

int              _txCanvas_SetRefreshLock    (int count);

HDC              _txBuffer_Create            (HWND wnd = NULL, const POINT* size = NULL, HBITMAP bitmap = NULL,
                                              RGBQUAD** pixels = NULL) tx_nodiscard;
bool             _txBuffer_Delete            (HDC* dc);
bool             _txBuffer_Select            (HGDIOBJ obj, HDC dc = txDC());

HWND             _txConsole_Attach();
bool             _txConsole_OK() tx_nodiscard;
bool             _txConsole_Detach           (bool activate);
bool             _txConsole_Draw             (HDC dc);
bool             _txConsole_SetUnicodeFont();

const char*       txRegisterClass            (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra);
HWND              txCreateExtraWindow        (CREATESTRUCT createData);
HICON            _txCreateTXIcon             (int size) tx_nodiscard;
int              _txSetFinishedText          (HWND wnd);
void             _txPauseBeforeTermination   (HWND canvas);
int              _txIsParentWaitable         (DWORD* parentPID = NULL) tx_nodiscard;
int              _txGetInput();

LRESULT CALLBACK _txPlayVideo_WndProc        (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
const char*      _txPlayVideo_FindVLC() tx_nodiscard;

bool             _txCreateShortcut           (const char shortcutName[],
                                              const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
                                              const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
                                              const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
                                              COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));

void*            _tx_DLGTEMPLATE_Create      (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                                              WORD controls, short x, short y, short cx, short cy,
                                              const char caption[], const char font[], WORD fontsize,
                                              const char menu[]) tx_nodiscard;

void*            _tx_DLGTEMPLATE_Add         (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                                              short x, short y, short cx, short cy,
                                              WORD id, const char wclass[], const char caption[]);

const char*      _txError                    (const char file[] = NULL, int line = 0, const char func[] = NULL, unsigned color = 0,
                                              const char msg[] = NULL, ...) tx_printfy (5);
const char*      _txProcessError             (const char file[], int line, const char func[], unsigned color,
                                              const char msg[], va_list args);
void             _txOnTerminate();
void             _txOnUnexpected();
void             _txOnPureCall();
void             _txOnNewHandlerAnsi();
int              _txOnNewHandler             (size_t size);
void             _txOnSignal                 (int signal = 0, int fpe = 0);
BOOL WINAPI      _txOnConsoleCtrlEvent       (DWORD type);
void             _txOnSecurityError          (int code, void*);
void             _txOnSecurityErrorAnsi      (const char* msg, void* ptr, int code);
int              _txOnMatherr                (_exception* except);
void             _txOnInvalidParam           (const wchar_t* expr, const wchar_t* func, const wchar_t* file,
                                              unsigned line, uintptr_t);
int              _txOnAllocHook              (int type, void* data, size_t size, int use, long request,
                                              const unsigned char* file, int line);
int              _txOnRTCFailure             (int type, const char* file, int line, const char* module, const char* format, ...) tx_printfy (5);
int              _txOnErrorReport            (int type, const char* text, int* ret);
int               tx_glGetError              (int setError = INT_MIN);

void             _txOnCExit();
void             _txOnExit                   (int      retcode);
void             _txOnFatalExit              (int      retcode);
void             _txOnExitProcess            (unsigned retcode);
void             _txOnFatalAppExitA          (unsigned action, const char message[]);
bool             _txOnTerminateProcess       (HANDLE process, unsigned retcode);
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
                 _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter);
void             _txWatchdogTerminator       (void* timeout);  // Only Arnold-type series are supported, not T1000

long WINAPI      _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc);
long WINAPI      _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc);
long             _txOnExceptionSEH           (EXCEPTION_POINTERS* exc, const char func[]);
intptr_t         _txDumpExceptionSEH         (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[]);
intptr_t         _txDumpExceptionObj         (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type);
intptr_t         _txDumpExceptionCPP         (char what[], intptr_t size, unsigned code = 0,
                                              unsigned params = 0, const ULONG_PTR info[] = NULL);

void             _txStackBackTrace           (const char file[] = "?", int line = 0, const char func[] = "?",
                                              bool readSource = true);
const char*      _txCaptureStackBackTrace    (int framesToSkip = 0, bool readSource = true,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
int              _txStackWalk                (int framesToSkip, size_t szCapture, void* capture[], unsigned long* backTraceHash,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
const char*      _txCaptureStackBackTraceTX  (int framesToSkip = 0, bool readSource = false);

const char*      _txSymPrintFromAddr         (void* addr = NULL, const char format[] = NULL, ...) tx_printfy (2);
bool             _txSymGetFromAddr           (void* addr, Win32::SYMBOL_INFO** symbol = NULL,
                                              Win32::IMAGEHLP_LINE64** line = NULL, const char** module = NULL,
                                              const char** source = NULL, int context = 2);
intptr_t         _txReadSource               (char buf[], intptr_t size, const char file[],
                                              int linStart = 0, int linEnd = INT_MIN, int linMark = INT_MIN);
bool             _txCreateMiniDump           (EXCEPTION_POINTERS* exc);

uintptr_t        _txSetProcAddress           (const char funcName[], uintptr_t newFunc, const char dllName[] = NULL,
                                              int useHotPatching = false, HMODULE module = NULL, bool debug = false);
bool             _txInDll() tx_nodiscard;
PROCESSENTRY32*  _txFindProcess              (unsigned pid = GetCurrentProcessId()) tx_nodiscard;
bool             _txKillProcess              (DWORD pid);
bool             _txIsBadReadPtr             (const void* address);
bool             _txCheckSourceCP            (int needCP = _TX_CODEPAGE, bool verbose = true);
bool             _txGetCommandLine           (wchar_t cmdLine[], size_t szCmdLine, unsigned pid = _getpid());
IMAGE_NT_HEADERS*_txGetNtHeaders             (HMODULE module = GetModuleHandle (NULL)) tx_nodiscard;
const char*      _txAppInfo() tx_nodiscard;

intptr_t         _tx_snprintf_s              (char stream[], intptr_t size, const char format[], ...) tx_printfy (3);
intptr_t         _tx_vsnprintf_s             (char stream[], intptr_t size, const char format[], va_list arg);
void              txReopenStdio();

#if defined (_CLANG_VER) && !defined (_MSC_VER)
void             _txLibCppDebugFunction      (std::__libcpp_debug_info const& info);
#endif

#if defined (__CYGWIN__)

int              _getch();
int              _putch (int ch);
int              _kbhit() tx_nodiscard;

#endif

//-----------------------------------------------------------------------------------------------------------------
// There are macros for __FILE__ and __LINE__ to work properly.

#if !defined (NDEBUG)

    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) && \
                                                     (assert (cond), true) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå."), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("Ïàðàìåòð \"%s\" íåâåðåí. Âîçìîæíî, ýòîò õîëñò íå ñîçäàí, " \
                                                                "èëè óæå óíè÷òîæåí, èëè íå çàãðóçèëàñü êàðòèíêà.", #dc), 1) )
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( (!(dc) &&                                           \
                                                     _TX_TXWINDOW_FAILED()) || _TX_HDC_FAILED (dc) )

#else
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define _TX_DEFAULT_HDC_FAILED(dc)         ( !(dc) &&                                            \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
#endif

//-----------------------------------------------------------------------------------------------------------------
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but MSVC rejects it. So sad. :'(

#if !defined (NDEBUG)
    #define  _TX_ON_DEBUG( code )              { code; }
#else
    #define  _TX_ON_DEBUG( code )              ;
#endif

//-----------------------------------------------------------------------------------------------------------------
// Invokes an error without location information. "$$" restores TX-related call location context

#define _TX_UNEXPECTED( ... )                  $$ _txError (NULL, 0, NULL, 0, ##__VA_ARGS__)

//-----------------------------------------------------------------------------------------------------------------
// Safe call of a function via its pointer

#define _TX_CALL(  func, param )               ( (func)? ((func) param) :       0 )
#define _TX_CALLv( func, param )               ( (func)? ((func) param) : (void)0 )

//-----------------------------------------------------------------------------------------------------------------
// This is a macro because cond is an expression and is not always a function. Lack of lambdas in pre-C++0x.

#define      _txWaitFor( cond, time )          { for (DWORD _t = GetTickCount() + (time); \
                                                      !(cond) && GetTickCount() < _t;     \
                                                      Sleep (_txWindowUpdateInterval)) ;  \
                                                 if  (!(cond))                            \
                                                      _txTrace (__FILE__, __LINE__, NULL, "WARNING: Timeout: " #cond "."); }
//-----------------------------------------------------------------------------------------------------------------
// Detouring in case of SEH mechanism

#define _txSetJmp()                            ( setjmp (_txDumpExceptionObjJmp) == 0 )

#define _txClearJmp()                          { *(unsigned long long*) _txDumpExceptionObjJmp = 0; }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal global data
//! @name    Âíóòðåííèå ãëîáàëüíûå äàííûå
//
//           Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
//           Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåð, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
//           Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
//           Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé, èëè êëàññ.
//=================================================================================================================
//! @{

int                          _txInitialized              = _TX_NOINIT || _txInitialize();

volatile const unsigned      _txCanaryFirst              = 0x776F656D; // A very system value

volatile unsigned            _txMainThreadId             = 0;          // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
volatile HANDLE              _txMainThread               = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà

volatile unsigned            _txCanvas_ThreadId          = 0;          // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
volatile HANDLE              _txCanvas_Thread            = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
volatile HWND                _txCanvas_Window            = NULL;       // Äåñêðèïòîð îêíà õîëñòà TXLib

HDC                          _txCanvas_BackBuf[2]        = {NULL,      // [0] Main TXLib in-memory DC, where user's pictures lies
                                                            NULL};     // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()

RGBQUAD*                     _txCanvas_Pixels            = NULL;       // Memory buffer of _txCanvas_BackBuf[0]

HBITMAP                      _txStockBitmap              = NULL;       // Equivalent of GetStockObject (BITMAP),
                                                                       // see https://devblogs.microsoft.com/oldnewthing/20100416-00/?p=14313

CRITICAL_SECTION             _txCanvas_LockBackBuf       = {0,-1};     // Prevent simultaneous access to back buffer, see txLock()

UINT_PTR                     _txCanvas_RefreshTimer      = 1;          // Timer ID to redraw TXLib window
volatile int                 _txCanvas_RefreshLock       = 0;          // Blocks auto on-timer canvas update, see txBegin/txEnd

::std::vector<HDC>*          _txCanvas_UserDCs           = NULL;       // List of DCs allocated, for auto-free

volatile bool                _txConsole_IsBlinking       = true;       // To blink or not to blink, that is the question.

bool                         _txConsole                  = false;      // Only first TXLib module in app can own the console
bool                         _txMain                     = false;      // First TXLib wnd opened (closing it terminates program)
bool                         _txIsDll                    = false;      // TXLib module is in DLL
volatile bool                _txRunning                  = false;      // main() is still running
volatile bool                _txExit                     = false;      // exit() is active

volatile POINT               _txMousePos                 = {-1,-1};    // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
volatile unsigned            _txMouseButtons             = 0;

volatile WNDPROC             _txAltWndProc               = NULL;       // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().

_tx_thread _txLoc            _txLoc::Cur                 = {};         // Execution point tracking and trace state, see "$" macro

volatile int                 _txErrors                   = 0;          // TX_ERROR calls sequental number
int                          _txOGLError                 = 0;          // Last OpenGL error when using tx_glGetError()
volatile long                _txSENumber                 = 0;          // SEH exceptions sequental number
volatile long                _txSEFatalNumber            = 0;          // SEH fatal exceptions sequental number
char                         _txDumpSE [_TX_BUFSIZE]     = "";         // SEH dump data area
char                         _txTraceSE[_TX_HUGEBUFSIZE] = "";         // Stack trace data area

LPTOP_LEVEL_EXCEPTION_FILTER _txPrevUEFilter             = NULL;       // Previous UnhandledExceptionFilter

jmp_buf                      _txDumpExceptionObjJmp      = {};         // Hook for _txDumpExceptionObj

const volatile uintptr_t     _txForceImport[]            = { (uintptr_t) ::TerminateProcess,              (uintptr_t) ::ExitProcess,
                                                             (uintptr_t) ::FatalExit,                     (uintptr_t) ::FatalAppExitA,
                                                             (uintptr_t) ::exit,                          (uintptr_t) Win32::_controlfp,
                                                             (uintptr_t) Win32::Polyline,                 (uintptr_t) Win32::PolyBezier,
                                                             (uintptr_t) Win32::RoundRect,                (uintptr_t) Win32::RemoveVectoredExceptionHandler,
                                                             (uintptr_t) Win32::PlgBlt,                   (uintptr_t) Win32::RtlCaptureStackBackTrace,
                                                             (uintptr_t) Win32::SymInitialize,            (uintptr_t) Win32::MinGW::SymInitialize,
                                                             (uintptr_t) Win32::SymSetOptions,            (uintptr_t) Win32::MinGW::SymSetOptions,
                                                             (uintptr_t) Win32::SymGetLineFromAddr64,     (uintptr_t) Win32::MinGW::SymGetLineFromAddr64,
                                                             (uintptr_t) Win32::SymFromAddr,              (uintptr_t) Win32::MinGW::SymFromAddr,
                                                             (uintptr_t) Win32::SymCleanup,               (uintptr_t) Win32::MinGW::SymCleanup,
                                                             (uintptr_t) Win32::SymGetModuleBase64,       (uintptr_t) Win32::MinGW::SymGetModuleBase64,
                                                             (uintptr_t) Win32::SymFunctionTableAccess64, (uintptr_t) Win32::MinGW::SymFunctionTableAccess64,
                                                             (uintptr_t) Win32::StackWalk64,              (uintptr_t) Win32::MinGW::StackWalk64,
                                                             (uintptr_t) Win32::StrStrIA,                 (uintptr_t) Win32::Wow64GetThreadContext };

volatile const unsigned      _txCanaryLast               = 0x5E2E2E5E; // Another very system value

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib engine init/check/cleanup
//! @name    Èíèöèàëèçàöèÿ/ïðîâåðêà/çàâåðøåíèå TXLib
//=================================================================================================================
//! @{

//-----------------------------------------------------------------------------------------------------------------
//{          Early initialization
//-----------------------------------------------------------------------------------------------------------------

int _txInitialize()
    {
    if (_txInitialized) return 1;
    _txInitialized = 1;

    #if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)  // See http://msdn.microsoft.com/en-us/library/w2fhc9a3%28v=vs.90%29.aspx
    _CrtSetBreakAlloc (_TX_ALLOC_BREAK);                 // and http://support.microsoft.com/ru-ru/kb/151585
    #endif

    #if defined (_TX_ALLOW_TRACE)
    _txLocLvlSet (1);
    #endif

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
                                     "compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

    _txMainThreadId = GetCurrentThreadId();
    _txMainThread   = OpenThread (THREAD_ALL_ACCESS, false, _txMainThreadId);

$3  _txIsDll = _txInDll();

$   if (!_txIsDll)
        {
$       _txConsole = ! FindAtom ("_txConsole");
$       (void)          AddAtom ("_txConsole");
        }

$   if (_txConsole)
        {
$       _txCheckSourceCP (_TX_CODEPAGE, true);

$       unsigned long stackSize = _TX_STACKSIZE;
$       _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$       _txOnSignal();

$       if (!*_txLogName)
            {$ _tx_snprintf_s (_txLogName, sizeof (_txLogName) - 1, "%s.log", txGetModuleFileName()); }

$       if (!_txIsDll)
            {
$           _TX_CALL  (Win32::AddVectoredExceptionHandler, (1, (PVECTORED_EXCEPTION_HANDLER)  _txVectoredExceptionHandler));
$           _txPrevUEFilter = SetUnhandledExceptionFilter  (   (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter);
            }

$       ::std::set_terminate             (_txOnTerminate);
$       ::std::set_new_handler           (_txOnNewHandlerAnsi);
$       _TX_CALL (Win32::set_unexpected, (_txOnUnexpected));

        #if defined (_CLANG_VER) && !defined (_MSC_VER)
$       ::std::__libcpp_debug_function = _txLibCppDebugFunction;
        #endif

$       SetConsoleCtrlHandler (_txOnConsoleCtrlEvent, true);

$       SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);

        #if defined (_MSC_VER)

$       _set_printf_count_output (1);

$       _set_new_handler (_txOnNewHandler);
$       _set_new_mode (1);

        #if !defined (_CLANG_VER)

$       _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$       _CrtSetAllocHook (_txOnAllocHook);

$       unsigned mode = _CRTDBG_MODE_FILE;
$       if (_CrtSetReportHook2 (_CRT_RPTHOOK_INSTALL, (_CRT_REPORT_HOOK) _txOnErrorReport) > 0) mode = 0;

$       _CrtSetReportMode (_CRT_WARN,   _CRTDBG_MODE_DEBUG | mode);
$       _CrtSetReportMode (_CRT_ERROR,  _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportFile (_CRT_WARN,   _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ERROR,  _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);

        #endif

$       _set_abort_behavior (_WRITE_ABORT_MSG, _WRITE_ABORT_MSG);
$       _set_abort_behavior (0,                _CALL_REPORTFAULT);

$       _RTC_SetErrorFunc              (_txOnRTCFailure);
$       _set_purecall_handler          (_txOnPureCall);
$       _set_invalid_parameter_handler (_txOnInvalidParam);

        #endif

        #if defined (__STDC_LIB_EXT1__)
$       ::std::set_constraint_handler_s (_txOnSecurityErrorAnsi);
        #endif

        #if !defined (__CYGWIN__) && defined (_GCC_VER) && (_GCC_VER >= 530) && !defined (i386)
$       __setusermatherr (_txOnMatherr);
        #endif

        #if !defined (__CYGWIN__)
$       _set_error_mode (_OUT_TO_MSGBOX | _OUT_TO_STDERR);
        #endif

$       HWND console = _txConsole_Attach();
$       SetWindowTextA (console, txGetModuleFileName (false));
        }

$   InitializeCriticalSection (&_txCanvas_LockBackBuf);

$   _txSetProcAddress ("ExitProcess",                 (uintptr_t) _txOnExitProcess,                 "KERNEL32.DLL");
$   _txSetProcAddress ("TerminateProcess",            (uintptr_t) _txOnTerminateProcess,            "KERNEL32.DLL");
$   _txSetProcAddress ("FatalExit",                   (uintptr_t) _txOnFatalExit,                   "KERNEL32.DLL");
$   _txSetProcAddress ("FatalAppExitA",               (uintptr_t) _txOnFatalAppExitA,               "KERNEL32.DLL");
$   _txSetProcAddress ("UnhandledExceptionFilter",    (uintptr_t) _txUnhandledExceptionFilter,      "KERNEL32.DLL", true);
$   _txSetProcAddress ("SetUnhandledExceptionFilter", (uintptr_t) _txOnSetUnhandledExceptionFilter, "KERNEL32.DLL");
$   _txSetProcAddress ("exit",                        (uintptr_t) _txOnExit);
$   _txSetProcAddress ("_cexit",                      (uintptr_t) _txOnCExit);

$   atexit (_txCleanup);

$   if (_txConsole)
        {
$       txSetConsoleAttr (FOREGROUND_LIGHTGRAY);

$       tx_fpreset();

$       srand ((unsigned) time (NULL));

$       SetLastError (0);
$       errno = 0;

        #if !defined (__CYGWIN__)
$       _doserrno = 0;
        #endif
        }

$   HDC dc = Win32::CreateCompatibleDC (NULL); dc asserted;
$   _txStockBitmap = (HBITMAP) Win32::SelectObject (dc, Win32::CreateCompatibleBitmap (dc, 1, 1)); _txStockBitmap asserted;
$   Win32::DeleteObject (Win32::SelectObject (dc, _txStockBitmap)) asserted;
$   Win32::DeleteDC (dc) asserted;

$   return 1;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCheckSourceCP (int needCP /*= _TX_CODEPAGE*/, bool verbose /*= true*/)
    {
$3  const char* sCodePage = NULL;
$   int codePage = 0;

$   switch (((unsigned const char*) "À") [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }

$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please

$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }

$   return (codePage == needCP);
    }

//-----------------------------------------------------------------------------------------------------------------

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;

    static char dllPaths [2][MAX_PATH] = {"", ""};

    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";

        // dllPaths[0] is relative to the TX Setup directory stored in the Registry

        char* path = dllPaths[0];

        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);

        // dllPaths[1] is relative to TXib.h file used in compilation

        path = dllPaths[1];

        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }

        if (char* dir = strrchr (path, '\\')) *dir = 0;

        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }

    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);

    if (arch)
        {
        assert (arch >= dllFileName);

        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));

        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }

    HMODULE   dll = GetModuleHandle (dllFileName);

    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);

    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);

        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);

        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }

    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);

    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;

    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);

    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè
#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
    // äåëå ýòî ñäåëàíî âðó÷íóþ ÷åðåç #undef. ×òîáû ïîä÷åðêíóòü èõ ëîêàëüíóþ ïðèðîäó, ó íèõ èìåíà çàêàí÷èâàþòñÿ íà _.
    // Òàêèå äåôàéíû ïîòîì íå ïåðåêîñÿ÷àò âåñü êîä ïîñëå òîãî êàê, ôàêòè÷åñêè, ñòàëè óæå íå íóæíû.
    //-------------------------------------------------------------------------------------------------------------
 
    #undef ID_TEXT_
    #undef ID_INPUT_
 
    //-------------------------------------------------------------------------------------------------------------
    // Ýòî ñòàòè÷åñêèé îáúåêò, ïîòîìó ÷òî ñòðîêà â íåì äîëæíà æèòü ïîñëå çàâåðøåíèÿ ôóíêöèè.
    //-------------------------------------------------------------------------------------------------------------
 
    static inputDlg dlg;
 
    //-------------------------------------------------------------------------------------------------------------
    // Ïåðåäàåì layout è çàïóñêàåì îêíî äèàëîãà    //-------------------------------------------------------------------------------------------------------------

    dlg.dialogBox (layout);

    //-------------------------------------------------------------------------------------------------------------
    // Âîçâðàùàåì àäðåñ ñòðîêè èç ñòàòè÷åñêîãî îáúåêòà. Òàê ìîæíî äåëàòü, ïîòîìó ÷òî ñòàòè÷åñêèé îáúåêò íå óìðåò
    // ïðè âûõîäå èç ôóíêöèè è ñòðîêà â íåì, ñîîòâåòñòâåííî, òîæå. Àäðåñ íåñòàòè÷åñêèõ ïåðåìåííûõ ïåðåäàâàòü
    // ñèíòàêñè÷åñêè ìîæíî, íî âåäåò ê ñåðüåçíûì îøèáêàì.
    //-------------------------------------------------------------------------------------------------------------

    return dlg.str;
    }

//! @}
//}
//=================================================================================================================

//}
//=================================================================================================================

//=================================================================================================================
//{          TXLIB IMPLEMENTATION
//           Ðåàëèçàöèÿ ôóíêöèé áèáëèîòåêè
//=================================================================================================================
//! @cond INTERNAL

//=================================================================================================================
//{          DLL functions import, missing types definitions
//! @name    Èìïîðò âíåøíèõ áèáëèîòåê, îïðåäåëåíèå íåäîñòàþùèõ òèïîâ
//=================================================================================================================
//! @{

namespace Win32 {

//-----------------------------------------------------------------------------------------------------------------
//{ Some of structs, consts and interfaces aren't defined in MinGW some early headers.
//  Copied from Windows SDK 7.0a.
//-----------------------------------------------------------------------------------------------------------------

#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                             0x01
#endif

#ifndef SMTO_ERRORONEXIT
#define SMTO_ERRORONEXIT                         0x0020
#endif

#ifndef NT_CONSOLE_PROPS_SIG
#define NT_CONSOLE_PROPS_SIG                     0xA0000002
#endif

#ifndef NIIF_INFO
#define NIIF_INFO                                0x00000001
#define NIIF_WARNING                             0x00000002
#define NIIF_ERROR                               0x00000003
#endif

#ifndef NIF_INFO
#define NIF_STATE                                0x00000008
#define NIF_INFO                                 0x00000010
#endif

#ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
#define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS   0x00000004
#endif

#ifndef SYMOPT_CASE_INSENSITIVE
#define SYMOPT_CASE_INSENSITIVE                  0x00000001
#define SYMOPT_UNDNAME                           0x00000002
#define SYMOPT_DEFERRED_LOADS                    0x00000004
#define SYMOPT_NO_CPP                            0x00000008
#define SYMOPT_LOAD_LINES                        0x00000010
#define SYMOPT_OMAP_FIND_NEAREST                 0x00000020
#define SYMOPT_LOAD_ANYTHING                     0x00000040
#define SYMOPT_IGNORE_CVREC                      0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS              0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS              0x00000200
#define SYMOPT_EXACT_SYMBOLS                     0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS            0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH                 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES             0x00002000
#define SYMOPT_PUBLICS_ONLY                      0x00004000
#define SYMOPT_NO_PUBLICS                        0x00008000
#define SYMOPT_AUTO_PUBLICS                      0x00010000
#define SYMOPT_NO_IMAGE_SEARCH                   0x00020000
#define SYMOPT_SECURE                            0x00040000
#define SYMOPT_NO_PROMPTS                        0x00080000
#define SYMOPT_ALLOW_ZERO_ADDRESS                0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT         0x02000000
#define SYMOPT_FAVOR_COMPRESSED                  0x00800000
#define SYMOPT_FLAT_DIRECTORY                    0x00400000
#define SYMOPT_IGNORE_IMAGEDIR                   0x00200000
#define SYMOPT_OVERWRITE                         0x00100000
#define SYMOPT_DEBUG                             0x80000000
#endif

// SEH exception codes. For GCC, see http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 64-66.

#ifndef STATUS_POSSIBLE_DEADLOCK
#define STATUS_POSSIBLE_DEADLOCK                 0xC0000194
#endif

#ifndef STATUS_FLOAT_MULTIPLE_FAULTS
#define STATUS_FLOAT_MULTIPLE_FAULTS             0xC00002B4
#endif

#ifndef STATUS_STACK_BUFFER_OVERRUN
#define STATUS_STACK_BUFFER_OVERRUN              0xC0000409
#endif

#ifndef STATUS_ASSERTION_FAILURE
#define STATUS_ASSERTION_FAILURE                 0xC0000420
#endif

#ifndef STATUS_WX86_BREAKPOINT
#define STATUS_WX86_BREAKPOINT                   0x4000001F
#endif

#ifndef DBG_PRINTEXCEPTION_C
#define DBG_PRINTEXCEPTION_C                     0x40010006  // OutputDebugStringA() call
#endif

#ifndef DBG_PRINTEXCEPTION_WIDE_C
#define DBG_PRINTEXCEPTION_WIDE_C                0x4001000A  // OutputDebugStringW() call
#endif

#ifndef DBG_THREAD_NAME
#define DBG_THREAD_NAME                          0x406D1388
#endif

#define EXCEPTION_CPP_MSC                        0xE06D7363  // '?msc'
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1       0x19930520  // '?msc' version magic, see ehdata.h
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2       0x19930521  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3       0x19930522  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1  0x01994000  // '?msc' version magic

#define EXCEPTION_CPP_GCC                        0x20474343  // ' GCC'
#define EXCEPTION_CPP_GCC_UNWIND                 0x21474343  // '!GCC'
#define EXCEPTION_CPP_GCC_FORCED                 0x22474343  // '"GCC'

#define EXCEPTION_CLR_FAILURE                    0xE0434f4D  // 'àCOM'

#define EXCEPTION_CPP_BORLAND_BUILDER            0x0EEDFAE6  // Should never occur here
#define EXCEPTION_CPP_BORLAND_DELPHI             0x0EEDFADE  // Should never occur here

#pragma pack (push, 1)

struct CONSOLE_CURSOR_INFO
    {
    DWORD dwSize;
    BOOL bVisible;
    };

struct CONSOLE_FONT_INFO
    {
    DWORD nFont;
    COORD dwFontSize;
    };

struct CONSOLE_FONT_INFOEX
    {
    ULONG cbSize;
    DWORD nFont;
    COORD dwFontSize;
    UINT  FontFamily;
    UINT  FontWeight;
    WCHAR FaceName[LF_FACESIZE];
    };

struct DATABLOCK_HEADER
    {
    DWORD cbSize;
    DWORD dwSignature;
    };

struct NT_CONSOLE_PROPS
    {
    DATABLOCK_HEADER dbh;

    WORD  wFillAttribute;
    WORD  wPopupFillAttribute;
    COORD dwScreenBufferSize;
    COORD dwWindowSize;
    COORD dwWindowOrigin;
    DWORD nFont;
    DWORD nInputBufferSize;
    COORD dwFontSize;
    UINT  uFontFamily;
    UINT  uFontWeight;
    WCHAR FaceName[LF_FACESIZE];
    UINT  uCursorSize;
    BOOL  bFullScreen;
    BOOL  bQuickEdit;
    BOOL  bInsertMode;
    BOOL  bAutoPosition;
    UINT  uHistoryBufferSize;
    UINT  uNumberOfHistoryBuffers;
    BOOL  bHistoryNoDup;

    COLORREF ColorTable[16];
    };

#pragma pack (pop)

#undef  INTERFACE
#define INTERFACE IShellLinkDataList

DECLARE_INTERFACE_ (IShellLinkDataList, IUnknown)
    {
    // *** IUnknown methods ***
    STDMETHOD (QueryInterface)  (THIS_ REFIID iid, void** value)    _tx_override PURE;
    STDMETHOD_(ULONG, AddRef)   (THIS)                              _tx_override PURE;
    STDMETHOD_(ULONG, Release)  (THIS)                              _tx_override PURE;

    // *** IShellLinkDataList methods ***
    STDMETHOD (AddDataBlock)    (THIS_ void* dataBlock)             PURE;
    STDMETHOD (CopyDataBlock)   (THIS_ DWORD sig, void** dataBlock) PURE;
    STDMETHOD (RemoveDataBlock) (THIS_ DWORD sig)                   PURE;
    STDMETHOD (GetFlags)        (THIS_ DWORD* flags)                PURE;
    STDMETHOD (SetFlags)        (THIS_ DWORD  flags)                PURE;

    protected:
    virtual ~IShellLinkDataList();
    };

const GUID IID_IShellLink         = {0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID IID_IShellLinkDataList = {0x45e2b4ae, 0xb1c3, 0x11d0, {0xb9,0x2f,0x00,0xa0,0xc9,0x03,0x12,0xe1}};
const GUID IID_IPersistFile       = {0x0000010b, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};

const GUID CLSID_SpVoice          = {0x96749377, 0x3391, 0x11d2, {0x9e,0xe3,0x00,0xc0,0x4f,0x79,0x73,0x96}};
const GUID IID_ISpVoice           = {0x6c44df74, 0x72b9, 0x4992, {0xa1,0xec,0xef,0x99,0x6e,0x04,0x22,0xd4}};

#undef  INTERFACE

typedef DWORD     NTSTATUS;
typedef ULONG_PTR KAFFINITY;
typedef LONG      KPRIORITY;

struct UNICODE_STRING
    {
    USHORT Length;
    USHORT MaximumLength;
    WCHAR* Buffer;
    };

struct RTL_USER_PROCESS_PARAMETERS
    {
    BYTE  Reserved1[16];
    void* Reserved2[10];
    UNICODE_STRING ImagePathName;
    UNICODE_STRING CommandLine;
    };

struct PEB
    {
    BYTE  Reserved1[2];
    BYTE  BeingDebugged;
    BYTE  Reserved2[1];
    void* Reserved3[2];
    void* Ldr;
    RTL_USER_PROCESS_PARAMETERS* ProcessParameters;
    void* Reserved4[3];
    void* AtlThunkSListPtr;
    void* Reserved5;
    ULONG Reserved6;
    void* Reserved7;
    ULONG Reserved8;
    ULONG AtlThunkSListPtr32;
    void* Reserved9[45];
    BYTE  Reserved10[96];
    void* PostProcessInitRoutine;
    BYTE  Reserved11[128];
    void* Reserved12[1];
    ULONG SessionId;
    };

struct PROCESS_BASIC_INFORMATION
    {
    NTSTATUS  ExitStatus;
    PEB*      PebBaseAddress;
    KAFFINITY AffinityMask;
    KPRIORITY BasePriority;
    ULONG_PTR UniqueProcessId;
    ULONG_PTR InheritedFromUniqueProcessId;
    };

enum ADDRESS_MODE
    {
    AddrMode1616,
    AddrMode1632,
    AddrModeReal,
    AddrModeFlat
    };

struct ADDRESS64
    {
    DWORD64      Offset;
    WORD         Segment;
    ADDRESS_MODE Mode;
    };

struct KDHELP64
    {
    DWORD64 Thread;
    DWORD   ThCallbackStack;
    DWORD   ThCallbackBStore;
    DWORD   NextCallback;
    DWORD   FramePointer;
    DWORD64 KiCallUserMode;
    DWORD64 KeUserCallbackDispatcher;
    DWORD64 SystemRangeStart;
    DWORD64 KiUserExceptionDispatcher;
    DWORD64 StackBase;
    DWORD64 StackLimit;
    DWORD64 Reserved[5];
    };

struct STACKFRAME64
    {
    ADDRESS64 AddrPC;
    ADDRESS64 AddrReturn;
    ADDRESS64 AddrFrame;
    ADDRESS64 AddrStack;
    ADDRESS64 AddrBStore;
    PVOID     FuncTableEntry;
    DWORD64   Params[4];
    BOOL      Far;
    BOOL      Virtual;
    DWORD64   Reserved[3];
    KDHELP64  KdHelp;
    };

struct WOW64_FLOATING_SAVE_AREA
    {
    DWORD ControlWord;
    DWORD StatusWord;
    DWORD TagWord;
    DWORD ErrorOffset;
    DWORD ErrorSelector;
    DWORD DataOffset;
    DWORD DataSelector;
    BYTE  RegisterArea[80];
    DWORD Cr0NpxState;
    };

#pragma pack (push, 4)

struct WOW64_CONTEXT
    {
    DWORD ContextFlags;

    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;

    WOW64_FLOATING_SAVE_AREA FloatSave;

    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;

    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;

    DWORD Ebp;
    DWORD Eip;
    DWORD SegCs;
    DWORD EFlags;
    DWORD Esp;
    DWORD SegSs;

    BYTE  ExtendedRegisters[512];
    };

#pragma pack (pop)

struct SYMBOL_INFO
    {
    ULONG   SizeOfStruct;
    ULONG   TypeIndex;
    ULONG64 Reserved[2];
    ULONG   info;
    ULONG   Size;
    ULONG64 ModBase;
    ULONG   Flags;
    ULONG64 Value;
    ULONG64 Address;
    ULONG   Register;
    ULONG   Scope;
    ULONG   Tag;
    ULONG   NameLen;
    ULONG   MaxNameLen;
    CHAR    Name[1];
    };

struct IMAGEHLP_LINE64
    {
    DWORD   SizeOfStruct;
    PVOID   Key;
    DWORD   LineNumber;
    PCHAR   FileName;
    DWORD64 Address;
    };

typedef bool    (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)   (HANDLE process, DWORD64 baseAddress, void* buffer, DWORD size, DWORD* bytesRead);
typedef void*   (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64) (HANDLE process, DWORD64 baseAddress);
typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)       (HANDLE process, DWORD64 address);
typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)     (HANDLE process, HANDLE thread, ADDRESS64* address);

typedef void (*unexpected_handler)();

#pragma pack (push, 4)

struct MINIDUMP_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    };

struct MINIDUMP_THREAD_EX_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    ULONG64  BackingStoreBase;
    ULONG64  BackingStoreEnd;
    };

struct MINIDUMP_MODULE_CALLBACK
    {
    wchar_t* FullPath;
    ULONG64  BaseOfImage;
    ULONG    SizeOfImage;
    ULONG    CheckSum;
    ULONG    TimeDateStamp;
    VS_FIXEDFILEINFO VersionInfo;
    void*    CvRecord;
    ULONG    SizeOfCvRecord;
    PVOID    MiscRecord;
    ULONG    SizeOfMiscRecord;
    };

struct MINIDUMP_INCLUDE_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    };

struct MINIDUMP_INCLUDE_MODULE_CALLBACK
    {
    ULONG64  BaseOfImage;
    };

struct MINIDUMP_MEMORY_INFO
    {
    ULONG64  BaseAddress;
    ULONG64  AllocationBase;
    ULONG32  AllocationProtect;
    ULONG32  __alignment1;
    ULONG64  RegionSize;
    ULONG32  State;
    ULONG32  Protect;
    ULONG32  Type;
    ULONG32  __alignment2;
    };

struct MINIDUMP_USER_STREAM
    {
    ULONG32  Type;
    ULONG    BufferSize;
    PVOID    Buffer;
    };

struct MINIDUMP_USER_STREAM_INFORMATION
    {
    ULONG                 UserStreamCount;
    MINIDUMP_USER_STREAM* UserStreamArray;
    };

struct MINIDUMP_CALLBACK_INPUT
    {
    ULONG    ProcessId;
    HANDLE   ProcessHandle;
    ULONG    CallbackType;

    union
        {
        MINIDUMP_THREAD_CALLBACK         Thread;
        MINIDUMP_THREAD_EX_CALLBACK      ThreadEx;
        MINIDUMP_MODULE_CALLBACK         Module;
        MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
        MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
        };
    };

struct MINIDUMP_CALLBACK_OUTPUT
    {
    union
        {
        ULONG ModuleWriteFlags;
        ULONG ThreadWriteFlags;
        ULONG SecondaryFlags;

        struct
            {
            ULONG64  MemoryBase;
            ULONG    MemorySize;
            };

        struct
            {
            unsigned CheckCancel;
            unsigned Cancel;
            };

        HANDLE Handle;
        };

    struct
        {
        MINIDUMP_MEMORY_INFO VmRegion;
        unsigned             Continue;
        };

    HRESULT Status;
    };

struct MINIDUMP_EXCEPTION_INFORMATION
    {
    DWORD               ThreadId;
    EXCEPTION_POINTERS* ExceptionPointers;
    unsigned            ClientPointers;
    };

typedef int (WINAPI* MINIDUMP_CALLBACK_ROUTINE) (void* param, MINIDUMP_CALLBACK_INPUT* input, MINIDUMP_CALLBACK_OUTPUT* output);

struct MINIDUMP_CALLBACK_INFORMATION
    {
    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
    void*                     CallbackParam;
    };

enum MINIDUMP_TYPE
    {
    MiniDumpNormal                         = 0x00000000,
    MiniDumpWithDataSegs                   = 0x00000001,
    MiniDumpWithFullMemory                 = 0x00000002,
    MiniDumpWithHandleData                 = 0x00000004,
    MiniDumpFilterMemory                   = 0x00000008,
    MiniDumpScanMemory                     = 0x00000010,
    MiniDumpWithUnloadedModules            = 0x00000020,
    MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
    MiniDumpFilterModulePaths              = 0x00000080,
    MiniDumpWithProcessThreadData          = 0x00000100,
    MiniDumpWithPrivateReadWriteMemory     = 0x00000200,
    MiniDumpWithoutOptionalData            = 0x00000400,
    MiniDumpWithFullMemoryInfo             = 0x00000800,
    MiniDumpWithThreadInfo                 = 0x00001000,
    MiniDumpWithCodeSegs                   = 0x00002000,
    MiniDumpWithoutAuxiliaryState          = 0x00004000,
    MiniDumpWithFullAuxiliaryState         = 0x00008000,
    MiniDumpWithPrivateWriteCopyMemory     = 0x00010000,
    MiniDumpIgnoreInaccessibleMemory       = 0x00020000,
    MiniDumpWithTokenInformation           = 0x00040000
    };

#pragma pack (pop)

#define FOREGROUND_BLACK         ( 0                                                         )
#define FOREGROUND_CYAN          ( FOREGROUND_BLUE       | FOREGROUND_GREEN                  )
#define FOREGROUND_MAGENTA       ( FOREGROUND_BLUE       | FOREGROUND_RED                    )
#define FOREGROUND_DARKYELLOW    ( FOREGROUND_GREEN      | FOREGROUND_RED                    )
#define FOREGROUND_LIGHTGRAY     ( FOREGROUND_BLUE       | FOREGROUND_GREEN | FOREGROUND_RED )
#define FOREGROUND_DARKGRAY      (                         FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTBLUE     ( FOREGROUND_BLUE       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTGREEN    ( FOREGROUND_GREEN      | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTCYAN     ( FOREGROUND_CYAN       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTRED      ( FOREGROUND_RED        | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTMAGENTA  ( FOREGROUND_MAGENTA    | FOREGROUND_INTENSITY              )
#define FOREGROUND_YELLOW        ( FOREGROUND_DARKYELLOW | FOREGROUND_INTENSITY              )
#define FOREGROUND_WHITE         ( FOREGROUND_LIGHTGRAY  | FOREGROUND_INTENSITY              )

#define BACKGROUND_BLACK         ( 0                                                         )
#define BACKGROUND_CYAN          ( BACKGROUND_BLUE       | BACKGROUND_GREEN                  )
#define BACKGROUND_MAGENTA       ( BACKGROUND_BLUE       | BACKGROUND_RED                    )
#define BACKGROUND_DARKYELLOW    ( BACKGROUND_GREEN      | BACKGROUND_RED                    )
#define BACKGROUND_GRAY          ( BACKGROUND_BLUE       | BACKGROUND_GREEN | BACKGROUND_RED )
#define BACKGROUND_DARKGRAY      (                         BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTBLUE     ( BACKGROUND_BLUE       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTGREEN    ( BACKGROUND_GREEN      | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTCYAN     ( BACKGROUND_CYAN       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTRED      ( BACKGROUND_RED        | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTMAGENTA  ( BACKGROUND_MAGENTA    | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTYELLOW   ( BACKGROUND_DARKYELLOW | BACKGROUND_INTENSITY              )
#define BACKGROUND_WHITE         ( BACKGROUND_DARKGRAY   | BACKGROUND_INTENSITY              )

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ There are copies of MSVC compiler built-in predefined definitions, which are wrong in 64-bit mode.
//  So we have to override them. See: http://stackoverflow.com/questions/39113168
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)
                                                    //  MS ABI C++ Exception Layout
namespace Win32 {                                   //  ---------------------------
                                                    //
#pragma pack (push, 4)                              //   EXCEPTION_RECORD:
                                                    //  +==================================================+
struct ThrowInfo                                    //  |...                                               |
    {                                               //  |NumberParameters:        3, 4 or more             |
    __int32 attributes;                             //  |ExceptionInformation[0]: MS signature 0x19930520  |
    __int32 pmfnUnwind;                             //  |ExceptionInformation[1]: object* thrown           |
    __int32 pForwardCompat;                         //  |ExceptionInformation[2]: ThrowInfo* --------------+---+
    __int32 pCatchableTypeArray;                    //  |ExceptionInformation[3]: ImageBase (if params > 3)|   |
    };                                              //  +==================================================+   |
                                                    //                                                         |
struct CatchableTypeArray                           //        ThrowInfo:                                       |
    {                                               //        +======================================+ <-------+
    __int32 nCatchableTypes;                        //        |   ...                                |
    __int32 arrayOfCatchableTypes[];                //  +-----+-- pCatchableTypeArray (ptr/RVA)      |
    };                                              //  |     +======================================+
                                                    //  |
struct CatchableType                                //  |     CatchableTypeArray:
    {                                               //  +---> +======================================+
    __int32 properties;                             //        |   ...                                |
    __int32 pType;                                  //  +-----+-- arrayOfCatchableTypes[0] (ptr/RVA) |
    __int32 thisDisplacement[3]; // struct _PMD     //  |     +======================================+
    __int32 sizeOrOffset;                           //  |
    __int32 copyFunction;                           //  |     CatchableType:
    };                                              //  +---> +====================+
                                                    //        | ...                |        std::type_info:
#pragma pack (pop)                                  //        | pType (ptr/RVA) ---+------> +==================+
                                                    //        | ...                |        |type_info data    |
} // namespace Win32                                //        +====================+        |...               |
                                                    //                                      +==================+
#endif

// Similar to __CxxDetectRethrow(), see C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\crtsrc\vcruntime\frame.cpp:

#define _TX_MSC__CXX_DETECT_RETHROW( exc )                                     \
    (                                                                          \
    (exc)                                          &&                          \
    (exc) -> ExceptionCode    == EXCEPTION_CPP_MSC &&                          \
    (exc) -> NumberParameters >= 3                 &&                          \
                                                                               \
    ((exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3) && \
                                                                               \
    (exc) -> ExceptionInformation[2] == 0                                      \
    )

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ The corresponding structures for GCC
//
//  From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/unwind-cxx.h
//  See:  http://mentorembedded.github.io/cxx-abi/abi-eh.html#cxx-abi
//-----------------------------------------------------------------------------------------------------------------

#if defined (_GCC_VER)
                                                    // GCC ABI C++ Exception layout. A/B are ExceptionInformation[0].
namespace ABI {                                     // --------------------------------------------------------------
                                                    //
struct __cxa_exception                              // Case A: "_Unwind_Exception* A" is undependent exception:
    {                                               // --------------------------------------------------------
    union {                                         //
        struct                                      //           __cxa_exception:           std::type_info:
            {                                       //       -*--+====================+     +==================+
            ::std::type_info* exceptionType;        //        ^  |exceptionType* -----+---->|type_info data    |
            void (*exceptionDestructor)(void*);     //        |  |...                 |     |...               |
            };                                      //       -1  |                    |     +==================+
        struct                                      //        |  |                    |
            {                                       // A >----|--+--------------------+
            __cxa_exception*  primaryException;     //     |  |  |unwindHeader        |
            void (*padding)();                      //    +1  |  |                    |
            };                                      //     |  |  |                    |
        };                                          //     V  |  |                    |
                                                    //    -*---  +====================+
    std::unexpected_handler   unexpectedHandler;    //           |object              |
    std::terminate_handler    terminateHandler;     //           +--------------------+
                                                    //
    __cxa_exception*          nextException;        // Case B: "_Unwind_Exception* B" is dependent exception
    int                       handlerCount;         // (unwindHeader.exception_class & 1 != 0):
    int                       handlerSwitchValue;   // -----------------------------------------------------
    const unsigned char*      actionRecord;         //
    const unsigned char*      languageSpecificData; //           __cxa_exception:               __cxa_exception:
    void*                     catchTemp;            //       -*--+====================+     -*--+=================+
    void*                     adjustedPtr;          //        ^  |primaryException* --+--    ^  |exceptionType*   |
                                                    //        |  |...                 |  \   |  |...              |
    _Unwind_Exception         unwindHeader;         //       -1  |                    |  |   |  |                 |
    };                                              //        |  |                    |  |   |  |                 |
                                                    // B >----|--+--------------------+  |  -1  +-----------------+
struct __cxa_eh_globals                             //     |  |  |unwindHeader        |  |   |  |unwindHeader     |
    {                                               //    +1  |  |                    |  |   |  |                 |
    __cxa_exception* caughtExceptions;              //     |  |  |                    |  |   |  |                 |
    unsigned int     uncaughtExceptions;            //     V  |  |                    |  \   |  |                 |
    };                                              //    -*---  +====================+   -->*--+=================+
                                                    //           |...                 |         |object           |
} // namespace ABI                                  //           .                    .         |                 |
                                                    //                                          +-----------------+

extern "C" ABI::__cxa_eh_globals* __cxa_get_globals();

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ Hand-made IAT.
//  Some IDEs don't link with these libs by default in console projects, so do sunrise by hand. :(
//-----------------------------------------------------------------------------------------------------------------

// Hand-made DLLIMPORT helpers

#define _TX_DLLIMPORT(     lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, true)

#define _TX_DLLIMPORT_OPT( lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, false)

#define _TX_DLLIMPORT_CRT( lib, retval, name, params ) \
     retval (      * name) params = (retval (      *) params) _txDllImport (lib ".dll", #name, false)

typedef void (*_tx_FARPROC)();

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required = true);

//-----------------------------------------------------------------------------------------------------------------

namespace Win32 {

_TX_DLLIMPORT     ("GDI32",    HDC,      CreateCompatibleDC,            (HDC dc));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateCompatibleBitmap,        (HDC dc, int width, int height));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetStockObject,                (int object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  SelectObject,                  (HDC dc, HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetCurrentObject,              (HDC dc, unsigned objectType));
_TX_DLLIMPORT     ("GDI32",    int,      GetObjectA,                    (HGDIOBJ obj, int bufsize, void* buffer));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GetObjectType,                 (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteDC,                      (HDC dc));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteObject,                  (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetTextColor,                  (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetBkColor,                    (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    int,      SetBkMode,                     (HDC dc, int bkMode));
_TX_DLLIMPORT     ("GDI32",    HFONT,    CreateFontA,                   (int height, int width, int escapement, int orientation,
                                                                         int weight, DWORD italic, DWORD underline, DWORD strikeout,
                                                                         DWORD charSet, DWORD outputPrec, DWORD clipPrec,
                                                                         DWORD quality, DWORD pitchAndFamily, const char face[]));
_TX_DLLIMPORT     ("GDI32",    int,      EnumFontFamiliesExA,           (HDC dc, LPLOGFONT logFont, FONTENUMPROC enumProc,
                                                                         LPARAM lParam, DWORD reserved));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetPixel,                      (HDC dc, int x, int y, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, GetPixel,                      (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    HPEN,     CreatePen,                     (int penStyle, int width, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    HBRUSH,   CreateSolidBrush,              (COLORREF color));
_TX_DLLIMPORT     ("GDI32",    bool,     MoveToEx,                      (HDC dc, int x, int y, POINT* point));
_TX_DLLIMPORT     ("GDI32",    bool,     LineTo,                        (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    bool,     Polygon,                       (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Polyline,                      (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     PolyBezier,                    (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Rectangle,                     (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     RoundRect,                     (HDC dc, int x0, int y0, int x1, int y1, int sizeX, int sizeY));
_TX_DLLIMPORT     ("GDI32",    bool,     Ellipse,                       (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     Arc,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Pie,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Chord,                         (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     TextOutA,                      (HDC dc, int x, int y, const char string[], int length));
_TX_DLLIMPORT     ("GDI32",    UINT,     SetTextAlign,                  (HDC dc, unsigned mode));
_TX_DLLIMPORT     ("GDI32",    bool,     GetTextExtentPoint32A,         (HDC dc, const char string[], int length, SIZE* size));
_TX_DLLIMPORT     ("GDI32",    bool,     ExtFloodFill,                  (HDC dc, int x, int y, COLORREF color, unsigned type));
_TX_DLLIMPORT     ("GDI32",    bool,     BitBlt,                        (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src,  int xSrc,  int ySrc,  DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     StretchBlt,                    (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src, int xSrc, int ySrc, int wSrc, int hSrc, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     PlgBlt,                        (HDC dest, const POINT* parallelogram,
                                                                         HDC src, int xSrc, int ySrc, int width, int height,
                                                                         HBITMAP mask, int xMask, int yMask));
_TX_DLLIMPORT     ("GDI32",    int,      SetDIBitsToDevice,             (HDC dc, int xDest, int yDest, DWORD width, DWORD height,
                                                                         int xSrc, int ySrc, unsigned startLine, unsigned numLines,
                                                                         const void* data, const BITMAPINFO* info, unsigned colorUse));
_TX_DLLIMPORT     ("GDI32",    int,      GetDIBits,                     (HDC hdc, HBITMAP hbmp, unsigned uStartScan, unsigned cScanLines,
                                                                         void* lpvBits, BITMAPINFO* lpbi, unsigned usage));
_TX_DLLIMPORT     ("GDI32",    bool,     PatBlt,                        (HDC dc, int x0, int y0, int width, int height, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    int,      SetROP2,                       (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    int,      SetStretchBltMode,             (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GdiSetBatchLimit,              (DWORD limit));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateDIBSection,              (HDC dc, const BITMAPINFO* bmInfo, unsigned colorUsage, void **vBits,
                                                                         HANDLE section, DWORD offset));

_TX_DLLIMPORT     ("User32",   int,      DrawTextA,                     (HDC dc, const char text[], int length, RECT* rect, unsigned format));
_TX_DLLIMPORT     ("User32",   HANDLE,   LoadImageA,                    (HINSTANCE inst, const char name[], unsigned type,
                                                                        int sizex, int sizey, unsigned mode));
_TX_DLLIMPORT_OPT ("User32",   bool,     IsHungAppWindow,               (HWND wnd));
_TX_DLLIMPORT_OPT ("User32",   HWND,     GhostWindowFromHungWindow,     (HWND wnd));

_TX_DLLIMPORT     ("WinMM",    bool,     PlaySound,                     (const char sound[], HMODULE mod, DWORD mode));

_TX_DLLIMPORT_OPT ("MSImg32",  bool,     TransparentBlt,                (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         unsigned transparentColor));
_TX_DLLIMPORT_OPT ("MSImg32",  bool,     AlphaBlend,                    (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         BLENDFUNCTION blending));

_TX_DLLIMPORT     ("Kernel32", void,     ExitProcess,                   (unsigned retcode));
_TX_DLLIMPORT     ("Kernel32", bool,     TerminateProcess,              (HANDLE process, unsigned retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalExit,                     (int retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalAppExitA,                 (unsigned action, const char message[]));
_TX_DLLIMPORT     ("Kernel32", HWND,     GetConsoleWindow,              (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetConsoleFont,                (HANDLE con, DWORD fontIndex));
_TX_DLLIMPORT_OPT ("Kernel32", DWORD,    GetNumberOfConsoleFonts,       (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFont,         (HANDLE con, bool maxWnd, CONSOLE_FONT_INFO*   curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", void,     RtlCaptureContext,             (CONTEXT* contextRecord));
_TX_DLLIMPORT_OPT ("Kernel32", USHORT,   RtlCaptureStackBackTrace,      (DWORD framesToSkip, DWORD framesToCapture, void** backTrace, DWORD* hash));
_TX_DLLIMPORT_OPT ("Kernel32", void*,    AddVectoredExceptionHandler,   (unsigned long firstHandler, PVECTORED_EXCEPTION_HANDLER handler));
_TX_DLLIMPORT_OPT ("Kernel32", unsigned, RemoveVectoredExceptionHandler,(void* handler));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetModuleHandleEx,             (DWORD flags, const char moduleName[], HMODULE* module));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     IsWow64Process,                (HANDLE process, int* isWow64Process));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     Wow64GetThreadContext,         (HANDLE thread, WOW64_CONTEXT* context));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetThreadStackGuarantee,       (unsigned long* stackSize));

_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoInitialize,                  (void*));
_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoCreateInstance,              (REFCLSID clsId, IUnknown*, DWORD, REFIID iId, PVOID* value));
_TX_DLLIMPORT     ("OLE32",    void,     CoUninitialize,                (void));

_TX_DLLIMPORT     ("Shell32",  HINSTANCE,ShellExecuteA,                 (HWND wnd, const char operation[], const char file[],
                                                                         const char parameters[], const char directory[], int showCmd));

_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIA,                      (const char    string[], const char    search[]));
_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIW,                      (const wchar_t string[], const wchar_t search[]));

_TX_DLLIMPORT_OPT ("NTDLL",    char*,    wine_get_version,              (void));
_TX_DLLIMPORT     ("NTDLL",    NTSTATUS, NtQueryInformationProcess,     (HANDLE process, int infoClass,
                                                                         void* processInfo, unsigned long szProcessInfo, unsigned long* szReturnInfo));

_TX_DLLIMPORT_CRT ("MSVCRT",   void,     exit,                          (int retcode));
_TX_DLLIMPORT_CRT ("MSVCRT",   void,     _cexit,                        (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _fpreset,                      (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _controlfp,                    (unsigned control, unsigned mask));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthread,                  (void (__cdecl* start_address) (void*), unsigned stack_size, void* arglist));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthreadex,                (void* security, unsigned stack_size, unsigned (__stdcall* start_address) (void*),
                                                                         void *arglist, unsigned init_flag, unsigned* thread_addr));
_TX_DLLIMPORT_CRT ("MSVCRT",   char*,    __unDName,                     (char* outStr, const char* mangledName, int outStrLen,
                                                                         void* (*mallocFunc) (size_t size), void (*freeFunc) (void *pointer),
                                                                         unsigned short flags));
_TX_DLLIMPORT_CRT ("MSVCRT",   unexpected_handler, set_unexpected,      (unexpected_handler handler));

_TX_DLLIMPORT_OPT ("OpenGL32", HDC,         wglGetCurrentDC,            (void));
_TX_DLLIMPORT_OPT ("OpenGL32", unsigned,    glGetError,                 (void));
_TX_DLLIMPORT_OPT ("Glu32",    const char*, gluErrorString,             (unsigned error));

_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     MiniDumpWriteDump,             (HANDLE process, DWORD processId, HANDLE file, MINIDUMP_TYPE dumpType,
                                                                         MINIDUMP_EXCEPTION_INFORMATION*   exceptionParam,
                                                                         MINIDUMP_USER_STREAM_INFORMATION* userStreamParam,
                                                                         MINIDUMP_CALLBACK_INFORMATION*    callbackParam));

_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("DbgHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
namespace MinGW {
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("MgwHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
} // namespace MinGW

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal function prototypes, macros and constants
//  @name    Ïðîòîòèïû âíóòðåííèõ ôóíêöèé, ìàêðîñû è êîíñòàíòû
//=================================================================================================================
//! @{

const int        _TX_IDM_ABOUT                            =   40000,       // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
                 _TX_IDM_CONSOLE                          =   40001,
                 _TX_WM_CREATEWND                         =   0x7FF0,      // Ñîîáùåíèÿ äëÿ ñîçäàíèÿ/óíè÷òîæåíèÿ
                 _TX_WM_DESTROYWND                        =   0x7FF1;      // îêîí â ïîòîêå Canvas

//-----------------------------------------------------------------------------------------------------------------

int              _txInitialize();
void             _txCleanup();

HWND             _txCanvas_CreateWindow      (const SIZE* size);
inline bool      _txCanvas_OK() tx_nodiscard;

bool             _txCanvas_OnCREATE          (HWND wnd);
bool             _txCanvas_OnDESTROY         (HWND wnd);
bool             _txCanvas_OnCLOSE           (HWND);
bool             _txCanvas_OnPAINT           (HWND wnd);
bool             _txCanvas_OnKEYDOWN         (HWND wnd, WPARAM vk, LPARAM info);
bool             _txCanvas_OnCHAR            (HWND wnd, WPARAM ch, LPARAM info);
bool             _txCanvas_OnTIMER           (HWND wnd, WPARAM id);
bool             _txCanvas_OnMOUSEMOVE       (HWND wnd, WPARAM buttons, LPARAM coords);
bool             _txCanvas_OnMOUSELEAVE      (HWND wnd);
bool             _txCanvas_OnCREATEWND       (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnDESTROYWND      (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnCmdCONSOLE      (HWND wnd, WPARAM cmd);
bool             _txCanvas_OnCmdABOUT        (HWND wnd, WPARAM cmd);

unsigned WINAPI  _txCanvas_ThreadProc        (void* data);
LRESULT CALLBACK _txCanvas_WndProc           (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);

int              _txCanvas_SetRefreshLock    (int count);

HDC              _txBuffer_Create            (HWND wnd = NULL, const POINT* size = NULL, HBITMAP bitmap = NULL,
                                              RGBQUAD** pixels = NULL) tx_nodiscard;
bool             _txBuffer_Delete            (HDC* dc);
bool             _txBuffer_Select            (HGDIOBJ obj, HDC dc = txDC());

HWND             _txConsole_Attach();
bool             _txConsole_OK() tx_nodiscard;
bool             _txConsole_Detach           (bool activate);
bool             _txConsole_Draw             (HDC dc);
bool             _txConsole_SetUnicodeFont();

const char*       txRegisterClass            (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra);
HWND              txCreateExtraWindow        (CREATESTRUCT createData);
HICON            _txCreateTXIcon             (int size) tx_nodiscard;
int              _txSetFinishedText          (HWND wnd);
void             _txPauseBeforeTermination   (HWND canvas);
int              _txIsParentWaitable         (DWORD* parentPID = NULL) tx_nodiscard;
int              _txGetInput();

LRESULT CALLBACK _txPlayVideo_WndProc        (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
const char*      _txPlayVideo_FindVLC() tx_nodiscard;

bool             _txCreateShortcut           (const char shortcutName[],
                                              const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
                                              const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
                                              const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
                                              COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));

void*            _tx_DLGTEMPLATE_Create      (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                                              WORD controls, short x, short y, short cx, short cy,
                                              const char caption[], const char font[], WORD fontsize,
                                              const char menu[]) tx_nodiscard;

void*            _tx_DLGTEMPLATE_Add         (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                                              short x, short y, short cx, short cy,
                                              WORD id, const char wclass[], const char caption[]);

const char*      _txError                    (const char file[] = NULL, int line = 0, const char func[] = NULL, unsigned color = 0,
                                              const char msg[] = NULL, ...) tx_printfy (5);
const char*      _txProcessError             (const char file[], int line, const char func[], unsigned color,
                                              const char msg[], va_list args);
void             _txOnTerminate();
void             _txOnUnexpected();
void             _txOnPureCall();
void             _txOnNewHandlerAnsi();
int              _txOnNewHandler             (size_t size);
void             _txOnSignal                 (int signal = 0, int fpe = 0);
BOOL WINAPI      _txOnConsoleCtrlEvent       (DWORD type);
void             _txOnSecurityError          (int code, void*);
void             _txOnSecurityErrorAnsi      (const char* msg, void* ptr, int code);
int              _txOnMatherr                (_exception* except);
void             _txOnInvalidParam           (const wchar_t* expr, const wchar_t* func, const wchar_t* file,
                                              unsigned line, uintptr_t);
int              _txOnAllocHook              (int type, void* data, size_t size, int use, long request,
                                              const unsigned char* file, int line);
int              _txOnRTCFailure             (int type, const char* file, int line, const char* module, const char* format, ...) tx_printfy (5);
int              _txOnErrorReport            (int type, const char* text, int* ret);
int               tx_glGetError              (int setError = INT_MIN);

void             _txOnCExit();
void             _txOnExit                   (int      retcode);
void             _txOnFatalExit              (int      retcode);
void             _txOnExitProcess            (unsigned retcode);
void             _txOnFatalAppExitA          (unsigned action, const char message[]);
bool             _txOnTerminateProcess       (HANDLE process, unsigned retcode);
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
                 _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter);
void             _txWatchdogTerminator       (void* timeout);  // Only Arnold-type series are supported, not T1000

long WINAPI      _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc);
long WINAPI      _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc);
long             _txOnExceptionSEH           (EXCEPTION_POINTERS* exc, const char func[]);
intptr_t         _txDumpExceptionSEH         (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[]);
intptr_t         _txDumpExceptionObj         (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type);
intptr_t         _txDumpExceptionCPP         (char what[], intptr_t size, unsigned code = 0,
                                              unsigned params = 0, const ULONG_PTR info[] = NULL);

void             _txStackBackTrace           (const char file[] = "?", int line = 0, const char func[] = "?",
                                              bool readSource = true);
const char*      _txCaptureStackBackTrace    (int framesToSkip = 0, bool readSource = true,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
int              _txStackWalk                (int framesToSkip, size_t szCapture, void* capture[], unsigned long* backTraceHash,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
const char*      _txCaptureStackBackTraceTX  (int framesToSkip = 0, bool readSource = false);

const char*      _txSymPrintFromAddr         (void* addr = NULL, const char format[] = NULL, ...) tx_printfy (2);
bool             _txSymGetFromAddr           (void* addr, Win32::SYMBOL_INFO** symbol = NULL,
                                              Win32::IMAGEHLP_LINE64** line = NULL, const char** module = NULL,
                                              const char** source = NULL, int context = 2);
intptr_t         _txReadSource               (char buf[], intptr_t size, const char file[],
                                              int linStart = 0, int linEnd = INT_MIN, int linMark = INT_MIN);
bool             _txCreateMiniDump           (EXCEPTION_POINTERS* exc);

uintptr_t        _txSetProcAddress           (const char funcName[], uintptr_t newFunc, const char dllName[] = NULL,
                                              int useHotPatching = false, HMODULE module = NULL, bool debug = false);
bool             _txInDll() tx_nodiscard;
PROCESSENTRY32*  _txFindProcess              (unsigned pid = GetCurrentProcessId()) tx_nodiscard;
bool             _txKillProcess              (DWORD pid);
bool             _txIsBadReadPtr             (const void* address);
bool             _txCheckSourceCP            (int needCP = _TX_CODEPAGE, bool verbose = true);
bool             _txGetCommandLine           (wchar_t cmdLine[], size_t szCmdLine, unsigned pid = _getpid());
IMAGE_NT_HEADERS*_txGetNtHeaders             (HMODULE module = GetModuleHandle (NULL)) tx_nodiscard;
const char*      _txAppInfo() tx_nodiscard;

intptr_t         _tx_snprintf_s              (char stream[], intptr_t size, const char format[], ...) tx_printfy (3);
intptr_t         _tx_vsnprintf_s             (char stream[], intptr_t size, const char format[], va_list arg);
void              txReopenStdio();

#if defined (_CLANG_VER) && !defined (_MSC_VER)
void             _txLibCppDebugFunction      (std::__libcpp_debug_info const& info);
#endif

#if defined (__CYGWIN__)

int              _getch();
int              _putch (int ch);
int              _kbhit() tx_nodiscard;

#endif

//-----------------------------------------------------------------------------------------------------------------
// There are macros for __FILE__ and __LINE__ to work properly.

#if !defined (NDEBUG)

    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) && \
                                                     (assert (cond), true) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå."), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("Ïàðàìåòð \"%s\" íåâåðåí. Âîçìîæíî, ýòîò õîëñò íå ñîçäàí, " \
                                                                "èëè óæå óíè÷òîæåí, èëè íå çàãðóçèëàñü êàðòèíêà.", #dc), 1) )
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( (!(dc) &&                                           \
                                                     _TX_TXWINDOW_FAILED()) || _TX_HDC_FAILED (dc) )

#else
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define _TX_DEFAULT_HDC_FAILED(dc)         ( !(dc) &&                                            \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
#endif

//-----------------------------------------------------------------------------------------------------------------
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but MSVC rejects it. So sad. :'(

#if !defined (NDEBUG)
    #define  _TX_ON_DEBUG( code )              { code; }
#else
    #define  _TX_ON_DEBUG( code )              ;
#endif

//-----------------------------------------------------------------------------------------------------------------
// Invokes an error without location information. "$$" restores TX-related call location context

#define _TX_UNEXPECTED( ... )                  $$ _txError (NULL, 0, NULL, 0, ##__VA_ARGS__)

//-----------------------------------------------------------------------------------------------------------------
// Safe call of a function via its pointer

#define _TX_CALL(  func, param )               ( (func)? ((func) param) :       0 )
#define _TX_CALLv( func, param )               ( (func)? ((func) param) : (void)0 )

//-----------------------------------------------------------------------------------------------------------------
// This is a macro because cond is an expression and is not always a function. Lack of lambdas in pre-C++0x.

#define      _txWaitFor( cond, time )          { for (DWORD _t = GetTickCount() + (time); \
                                                      !(cond) && GetTickCount() < _t;     \
                                                      Sleep (_txWindowUpdateInterval)) ;  \
                                                 if  (!(cond))                            \
                                                      _txTrace (__FILE__, __LINE__, NULL, "WARNING: Timeout: " #cond "."); }
//-----------------------------------------------------------------------------------------------------------------
// Detouring in case of SEH mechanism

#define _txSetJmp()                            ( setjmp (_txDumpExceptionObjJmp) == 0 )

#define _txClearJmp()                          { *(unsigned long long*) _txDumpExceptionObjJmp = 0; }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal global data
//! @name    Âíóòðåííèå ãëîáàëüíûå äàííûå
//
//           Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
//           Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåð, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
//           Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
//           Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé, èëè êëàññ.
//=================================================================================================================
//! @{

int                          _txInitialized              = _TX_NOINIT || _txInitialize();

volatile const unsigned      _txCanaryFirst              = 0x776F656D; // A very system value

volatile unsigned            _txMainThreadId             = 0;          // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
volatile HANDLE              _txMainThread               = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà

volatile unsigned            _txCanvas_ThreadId          = 0;          // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
volatile HANDLE              _txCanvas_Thread            = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
volatile HWND                _txCanvas_Window            = NULL;       // Äåñêðèïòîð îêíà õîëñòà TXLib

HDC                          _txCanvas_BackBuf[2]        = {NULL,      // [0] Main TXLib in-memory DC, where user's pictures lies
                                                            NULL};     // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()

RGBQUAD*                     _txCanvas_Pixels            = NULL;       // Memory buffer of _txCanvas_BackBuf[0]

HBITMAP                      _txStockBitmap              = NULL;       // Equivalent of GetStockObject (BITMAP),
                                                                       // see https://devblogs.microsoft.com/oldnewthing/20100416-00/?p=14313

CRITICAL_SECTION             _txCanvas_LockBackBuf       = {0,-1};     // Prevent simultaneous access to back buffer, see txLock()

UINT_PTR                     _txCanvas_RefreshTimer      = 1;          // Timer ID to redraw TXLib window
volatile int                 _txCanvas_RefreshLock       = 0;          // Blocks auto on-timer canvas update, see txBegin/txEnd

::std::vector<HDC>*          _txCanvas_UserDCs           = NULL;       // List of DCs allocated, for auto-free

volatile bool                _txConsole_IsBlinking       = true;       // To blink or not to blink, that is the question.

bool                         _txConsole                  = false;      // Only first TXLib module in app can own the console
bool                         _txMain                     = false;      // First TXLib wnd opened (closing it terminates program)
bool                         _txIsDll                    = false;      // TXLib module is in DLL
volatile bool                _txRunning                  = false;      // main() is still running
volatile bool                _txExit                     = false;      // exit() is active

volatile POINT               _txMousePos                 = {-1,-1};    // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
volatile unsigned            _txMouseButtons             = 0;

volatile WNDPROC             _txAltWndProc               = NULL;       // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().

_tx_thread _txLoc            _txLoc::Cur                 = {};         // Execution point tracking and trace state, see "$" macro

volatile int                 _txErrors                   = 0;          // TX_ERROR calls sequental number
int                          _txOGLError                 = 0;          // Last OpenGL error when using tx_glGetError()
volatile long                _txSENumber                 = 0;          // SEH exceptions sequental number
volatile long                _txSEFatalNumber            = 0;          // SEH fatal exceptions sequental number
char                         _txDumpSE [_TX_BUFSIZE]     = "";         // SEH dump data area
char                         _txTraceSE[_TX_HUGEBUFSIZE] = "";         // Stack trace data area

LPTOP_LEVEL_EXCEPTION_FILTER _txPrevUEFilter             = NULL;       // Previous UnhandledExceptionFilter

jmp_buf                      _txDumpExceptionObjJmp      = {};         // Hook for _txDumpExceptionObj

const volatile uintptr_t     _txForceImport[]            = { (uintptr_t) ::TerminateProcess,              (uintptr_t) ::ExitProcess,
                                                             (uintptr_t) ::FatalExit,                     (uintptr_t) ::FatalAppExitA,
                                                             (uintptr_t) ::exit,                          (uintptr_t) Win32::_controlfp,
                                                             (uintptr_t) Win32::Polyline,                 (uintptr_t) Win32::PolyBezier,
                                                             (uintptr_t) Win32::RoundRect,                (uintptr_t) Win32::RemoveVectoredExceptionHandler,
                                                             (uintptr_t) Win32::PlgBlt,                   (uintptr_t) Win32::RtlCaptureStackBackTrace,
                                                             (uintptr_t) Win32::SymInitialize,            (uintptr_t) Win32::MinGW::SymInitialize,
                                                             (uintptr_t) Win32::SymSetOptions,            (uintptr_t) Win32::MinGW::SymSetOptions,
                                                             (uintptr_t) Win32::SymGetLineFromAddr64,     (uintptr_t) Win32::MinGW::SymGetLineFromAddr64,
                                                             (uintptr_t) Win32::SymFromAddr,              (uintptr_t) Win32::MinGW::SymFromAddr,
                                                             (uintptr_t) Win32::SymCleanup,               (uintptr_t) Win32::MinGW::SymCleanup,
                                                             (uintptr_t) Win32::SymGetModuleBase64,       (uintptr_t) Win32::MinGW::SymGetModuleBase64,
                                                             (uintptr_t) Win32::SymFunctionTableAccess64, (uintptr_t) Win32::MinGW::SymFunctionTableAccess64,
                                                             (uintptr_t) Win32::StackWalk64,              (uintptr_t) Win32::MinGW::StackWalk64,
                                                             (uintptr_t) Win32::StrStrIA,                 (uintptr_t) Win32::Wow64GetThreadContext };

volatile const unsigned      _txCanaryLast               = 0x5E2E2E5E; // Another very system value

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib engine init/check/cleanup
//! @name    Èíèöèàëèçàöèÿ/ïðîâåðêà/çàâåðøåíèå TXLib
//=================================================================================================================
//! @{

//-----------------------------------------------------------------------------------------------------------------
//{          Early initialization
//-----------------------------------------------------------------------------------------------------------------

int _txInitialize()
    {
    if (_txInitialized) return 1;
    _txInitialized = 1;

    #if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)  // See http://msdn.microsoft.com/en-us/library/w2fhc9a3%28v=vs.90%29.aspx
    _CrtSetBreakAlloc (_TX_ALLOC_BREAK);                 // and http://support.microsoft.com/ru-ru/kb/151585
    #endif

    #if defined (_TX_ALLOW_TRACE)
    _txLocLvlSet (1);
    #endif

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
                                     "compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

    _txMainThreadId = GetCurrentThreadId();
    _txMainThread   = OpenThread (THREAD_ALL_ACCESS, false, _txMainThreadId);

$3  _txIsDll = _txInDll();

$   if (!_txIsDll)
        {
$       _txConsole = ! FindAtom ("_txConsole");
$       (void)          AddAtom ("_txConsole");
        }

$   if (_txConsole)
        {
$       _txCheckSourceCP (_TX_CODEPAGE, true);

$       unsigned long stackSize = _TX_STACKSIZE;
$       _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$       _txOnSignal();

$       if (!*_txLogName)
            {$ _tx_snprintf_s (_txLogName, sizeof (_txLogName) - 1, "%s.log", txGetModuleFileName()); }

$       if (!_txIsDll)
            {
$           _TX_CALL  (Win32::AddVectoredExceptionHandler, (1, (PVECTORED_EXCEPTION_HANDLER)  _txVectoredExceptionHandler));
$           _txPrevUEFilter = SetUnhandledExceptionFilter  (   (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter);
            }

$       ::std::set_terminate             (_txOnTerminate);
$       ::std::set_new_handler           (_txOnNewHandlerAnsi);
$       _TX_CALL (Win32::set_unexpected, (_txOnUnexpected));

        #if defined (_CLANG_VER) && !defined (_MSC_VER)
$       ::std::__libcpp_debug_function = _txLibCppDebugFunction;
        #endif

$       SetConsoleCtrlHandler (_txOnConsoleCtrlEvent, true);

$       SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);

        #if defined (_MSC_VER)

$       _set_printf_count_output (1);

$       _set_new_handler (_txOnNewHandler);
$       _set_new_mode (1);

        #if !defined (_CLANG_VER)

$       _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$       _CrtSetAllocHook (_txOnAllocHook);

$       unsigned mode = _CRTDBG_MODE_FILE;
$       if (_CrtSetReportHook2 (_CRT_RPTHOOK_INSTALL, (_CRT_REPORT_HOOK) _txOnErrorReport) > 0) mode = 0;

$       _CrtSetReportMode (_CRT_WARN,   _CRTDBG_MODE_DEBUG | mode);
$       _CrtSetReportMode (_CRT_ERROR,  _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportFile (_CRT_WARN,   _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ERROR,  _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);

        #endif

$       _set_abort_behavior (_WRITE_ABORT_MSG, _WRITE_ABORT_MSG);
$       _set_abort_behavior (0,                _CALL_REPORTFAULT);

$       _RTC_SetErrorFunc              (_txOnRTCFailure);
$       _set_purecall_handler          (_txOnPureCall);
$       _set_invalid_parameter_handler (_txOnInvalidParam);

        #endif

        #if defined (__STDC_LIB_EXT1__)
$       ::std::set_constraint_handler_s (_txOnSecurityErrorAnsi);
        #endif

        #if !defined (__CYGWIN__) && defined (_GCC_VER) && (_GCC_VER >= 530) && !defined (i386)
$       __setusermatherr (_txOnMatherr);
        #endif

        #if !defined (__CYGWIN__)
$       _set_error_mode (_OUT_TO_MSGBOX | _OUT_TO_STDERR);
        #endif

$       HWND console = _txConsole_Attach();
$       SetWindowTextA (console, txGetModuleFileName (false));
        }

$   InitializeCriticalSection (&_txCanvas_LockBackBuf);

$   _txSetProcAddress ("ExitProcess",                 (uintptr_t) _txOnExitProcess,                 "KERNEL32.DLL");
$   _txSetProcAddress ("TerminateProcess",            (uintptr_t) _txOnTerminateProcess,            "KERNEL32.DLL");
$   _txSetProcAddress ("FatalExit",                   (uintptr_t) _txOnFatalExit,                   "KERNEL32.DLL");
$   _txSetProcAddress ("FatalAppExitA",               (uintptr_t) _txOnFatalAppExitA,               "KERNEL32.DLL");
$   _txSetProcAddress ("UnhandledExceptionFilter",    (uintptr_t) _txUnhandledExceptionFilter,      "KERNEL32.DLL", true);
$   _txSetProcAddress ("SetUnhandledExceptionFilter", (uintptr_t) _txOnSetUnhandledExceptionFilter, "KERNEL32.DLL");
$   _txSetProcAddress ("exit",                        (uintptr_t) _txOnExit);
$   _txSetProcAddress ("_cexit",                      (uintptr_t) _txOnCExit);

$   atexit (_txCleanup);

$   if (_txConsole)
        {
$       txSetConsoleAttr (FOREGROUND_LIGHTGRAY);

$       tx_fpreset();

$       srand ((unsigned) time (NULL));

$       SetLastError (0);
$       errno = 0;

        #if !defined (__CYGWIN__)
$       _doserrno = 0;
        #endif
        }

$   HDC dc = Win32::CreateCompatibleDC (NULL); dc asserted;
$   _txStockBitmap = (HBITMAP) Win32::SelectObject (dc, Win32::CreateCompatibleBitmap (dc, 1, 1)); _txStockBitmap asserted;
$   Win32::DeleteObject (Win32::SelectObject (dc, _txStockBitmap)) asserted;
$   Win32::DeleteDC (dc) asserted;

$   return 1;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCheckSourceCP (int needCP /*= _TX_CODEPAGE*/, bool verbose /*= true*/)
    {
$3  const char* sCodePage = NULL;
$   int codePage = 0;

$   switch (((unsigned const char*) "À") [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }

$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please

$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }

$   return (codePage == needCP);
    }

//-----------------------------------------------------------------------------------------------------------------

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;

    static char dllPaths [2][MAX_PATH] = {"", ""};

    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";

        // dllPaths[0] is relative to the TX Setup directory stored in the Registry

        char* path = dllPaths[0];

        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);

        // dllPaths[1] is relative to TXib.h file used in compilation

        path = dllPaths[1];

        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }

        if (char* dir = strrchr (path, '\\')) *dir = 0;

        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }

    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);

    if (arch)
        {
        assert (arch >= dllFileName);

        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));

        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }

    HMODULE   dll = GetModuleHandle (dllFileName);

    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);

    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);

        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);

        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }

    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);

    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;

    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);

    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè
#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
    //-------------------------------------------------------------------------------------------------------------
 
    dlg.dialogBox (layout);
 
    //-------------------------------------------------------------------------------------------------------------
    // Âîçâðàùàåì àäðåñ ñòðîêè èç ñòàòè÷åñêîãî îáúåêòà. Òàê ìîæíî äåëàòü, ïîòîìó ÷òî ñòàòè÷åñêèé îáúåêò íå óìðåò    // ïðè âûõîäå èç ôóíêöèè è ñòðîêà â íåì, ñîîòâåòñòâåííî, òîæå. Àäðåñ íåñòàòè÷åñêèõ ïåðåìåííûõ ïåðåäàâàòü
    // ñèíòàêñè÷åñêè ìîæíî, íî âåäåò ê ñåðüåçíûì îøèáêàì.
    //-------------------------------------------------------------------------------------------------------------

    return dlg.str;
    }

//! @}
//}
//=================================================================================================================

//}
//=================================================================================================================

//=================================================================================================================
//{          TXLIB IMPLEMENTATION
//           Ðåàëèçàöèÿ ôóíêöèé áèáëèîòåêè
//=================================================================================================================
//! @cond INTERNAL

//=================================================================================================================
//{          DLL functions import, missing types definitions
//! @name    Èìïîðò âíåøíèõ áèáëèîòåê, îïðåäåëåíèå íåäîñòàþùèõ òèïîâ
//=================================================================================================================
//! @{

namespace Win32 {

//-----------------------------------------------------------------------------------------------------------------
//{ Some of structs, consts and interfaces aren't defined in MinGW some early headers.
//  Copied from Windows SDK 7.0a.
//-----------------------------------------------------------------------------------------------------------------

#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                             0x01
#endif

#ifndef SMTO_ERRORONEXIT
#define SMTO_ERRORONEXIT                         0x0020
#endif

#ifndef NT_CONSOLE_PROPS_SIG
#define NT_CONSOLE_PROPS_SIG                     0xA0000002
#endif

#ifndef NIIF_INFO
#define NIIF_INFO                                0x00000001
#define NIIF_WARNING                             0x00000002
#define NIIF_ERROR                               0x00000003
#endif

#ifndef NIF_INFO
#define NIF_STATE                                0x00000008
#define NIF_INFO                                 0x00000010
#endif

#ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
#define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS   0x00000004
#endif

#ifndef SYMOPT_CASE_INSENSITIVE
#define SYMOPT_CASE_INSENSITIVE                  0x00000001
#define SYMOPT_UNDNAME                           0x00000002
#define SYMOPT_DEFERRED_LOADS                    0x00000004
#define SYMOPT_NO_CPP                            0x00000008
#define SYMOPT_LOAD_LINES                        0x00000010
#define SYMOPT_OMAP_FIND_NEAREST                 0x00000020
#define SYMOPT_LOAD_ANYTHING                     0x00000040
#define SYMOPT_IGNORE_CVREC                      0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS              0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS              0x00000200
#define SYMOPT_EXACT_SYMBOLS                     0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS            0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH                 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES             0x00002000
#define SYMOPT_PUBLICS_ONLY                      0x00004000
#define SYMOPT_NO_PUBLICS                        0x00008000
#define SYMOPT_AUTO_PUBLICS                      0x00010000
#define SYMOPT_NO_IMAGE_SEARCH                   0x00020000
#define SYMOPT_SECURE                            0x00040000
#define SYMOPT_NO_PROMPTS                        0x00080000
#define SYMOPT_ALLOW_ZERO_ADDRESS                0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT         0x02000000
#define SYMOPT_FAVOR_COMPRESSED                  0x00800000
#define SYMOPT_FLAT_DIRECTORY                    0x00400000
#define SYMOPT_IGNORE_IMAGEDIR                   0x00200000
#define SYMOPT_OVERWRITE                         0x00100000
#define SYMOPT_DEBUG                             0x80000000
#endif

// SEH exception codes. For GCC, see http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 64-66.

#ifndef STATUS_POSSIBLE_DEADLOCK
#define STATUS_POSSIBLE_DEADLOCK                 0xC0000194
#endif

#ifndef STATUS_FLOAT_MULTIPLE_FAULTS
#define STATUS_FLOAT_MULTIPLE_FAULTS             0xC00002B4
#endif

#ifndef STATUS_STACK_BUFFER_OVERRUN
#define STATUS_STACK_BUFFER_OVERRUN              0xC0000409
#endif

#ifndef STATUS_ASSERTION_FAILURE
#define STATUS_ASSERTION_FAILURE                 0xC0000420
#endif

#ifndef STATUS_WX86_BREAKPOINT
#define STATUS_WX86_BREAKPOINT                   0x4000001F
#endif

#ifndef DBG_PRINTEXCEPTION_C
#define DBG_PRINTEXCEPTION_C                     0x40010006  // OutputDebugStringA() call
#endif

#ifndef DBG_PRINTEXCEPTION_WIDE_C
#define DBG_PRINTEXCEPTION_WIDE_C                0x4001000A  // OutputDebugStringW() call
#endif

#ifndef DBG_THREAD_NAME
#define DBG_THREAD_NAME                          0x406D1388
#endif

#define EXCEPTION_CPP_MSC                        0xE06D7363  // '?msc'
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1       0x19930520  // '?msc' version magic, see ehdata.h
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2       0x19930521  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3       0x19930522  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1  0x01994000  // '?msc' version magic

#define EXCEPTION_CPP_GCC                        0x20474343  // ' GCC'
#define EXCEPTION_CPP_GCC_UNWIND                 0x21474343  // '!GCC'
#define EXCEPTION_CPP_GCC_FORCED                 0x22474343  // '"GCC'

#define EXCEPTION_CLR_FAILURE                    0xE0434f4D  // 'àCOM'

#define EXCEPTION_CPP_BORLAND_BUILDER            0x0EEDFAE6  // Should never occur here
#define EXCEPTION_CPP_BORLAND_DELPHI             0x0EEDFADE  // Should never occur here

#pragma pack (push, 1)

struct CONSOLE_CURSOR_INFO
    {
    DWORD dwSize;
    BOOL bVisible;
    };

struct CONSOLE_FONT_INFO
    {
    DWORD nFont;
    COORD dwFontSize;
    };

struct CONSOLE_FONT_INFOEX
    {
    ULONG cbSize;
    DWORD nFont;
    COORD dwFontSize;
    UINT  FontFamily;
    UINT  FontWeight;
    WCHAR FaceName[LF_FACESIZE];
    };

struct DATABLOCK_HEADER
    {
    DWORD cbSize;
    DWORD dwSignature;
    };

struct NT_CONSOLE_PROPS
    {
    DATABLOCK_HEADER dbh;

    WORD  wFillAttribute;
    WORD  wPopupFillAttribute;
    COORD dwScreenBufferSize;
    COORD dwWindowSize;
    COORD dwWindowOrigin;
    DWORD nFont;
    DWORD nInputBufferSize;
    COORD dwFontSize;
    UINT  uFontFamily;
    UINT  uFontWeight;
    WCHAR FaceName[LF_FACESIZE];
    UINT  uCursorSize;
    BOOL  bFullScreen;
    BOOL  bQuickEdit;
    BOOL  bInsertMode;
    BOOL  bAutoPosition;
    UINT  uHistoryBufferSize;
    UINT  uNumberOfHistoryBuffers;
    BOOL  bHistoryNoDup;

    COLORREF ColorTable[16];
    };

#pragma pack (pop)

#undef  INTERFACE
#define INTERFACE IShellLinkDataList

DECLARE_INTERFACE_ (IShellLinkDataList, IUnknown)
    {
    // *** IUnknown methods ***
    STDMETHOD (QueryInterface)  (THIS_ REFIID iid, void** value)    _tx_override PURE;
    STDMETHOD_(ULONG, AddRef)   (THIS)                              _tx_override PURE;
    STDMETHOD_(ULONG, Release)  (THIS)                              _tx_override PURE;

    // *** IShellLinkDataList methods ***
    STDMETHOD (AddDataBlock)    (THIS_ void* dataBlock)             PURE;
    STDMETHOD (CopyDataBlock)   (THIS_ DWORD sig, void** dataBlock) PURE;
    STDMETHOD (RemoveDataBlock) (THIS_ DWORD sig)                   PURE;
    STDMETHOD (GetFlags)        (THIS_ DWORD* flags)                PURE;
    STDMETHOD (SetFlags)        (THIS_ DWORD  flags)                PURE;

    protected:
    virtual ~IShellLinkDataList();
    };

const GUID IID_IShellLink         = {0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID IID_IShellLinkDataList = {0x45e2b4ae, 0xb1c3, 0x11d0, {0xb9,0x2f,0x00,0xa0,0xc9,0x03,0x12,0xe1}};
const GUID IID_IPersistFile       = {0x0000010b, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};

const GUID CLSID_SpVoice          = {0x96749377, 0x3391, 0x11d2, {0x9e,0xe3,0x00,0xc0,0x4f,0x79,0x73,0x96}};
const GUID IID_ISpVoice           = {0x6c44df74, 0x72b9, 0x4992, {0xa1,0xec,0xef,0x99,0x6e,0x04,0x22,0xd4}};

#undef  INTERFACE

typedef DWORD     NTSTATUS;
typedef ULONG_PTR KAFFINITY;
typedef LONG      KPRIORITY;

struct UNICODE_STRING
    {
    USHORT Length;
    USHORT MaximumLength;
    WCHAR* Buffer;
    };

struct RTL_USER_PROCESS_PARAMETERS
    {
    BYTE  Reserved1[16];
    void* Reserved2[10];
    UNICODE_STRING ImagePathName;
    UNICODE_STRING CommandLine;
    };

struct PEB
    {
    BYTE  Reserved1[2];
    BYTE  BeingDebugged;
    BYTE  Reserved2[1];
    void* Reserved3[2];
    void* Ldr;
    RTL_USER_PROCESS_PARAMETERS* ProcessParameters;
    void* Reserved4[3];
    void* AtlThunkSListPtr;
    void* Reserved5;
    ULONG Reserved6;
    void* Reserved7;
    ULONG Reserved8;
    ULONG AtlThunkSListPtr32;
    void* Reserved9[45];
    BYTE  Reserved10[96];
    void* PostProcessInitRoutine;
    BYTE  Reserved11[128];
    void* Reserved12[1];
    ULONG SessionId;
    };

struct PROCESS_BASIC_INFORMATION
    {
    NTSTATUS  ExitStatus;
    PEB*      PebBaseAddress;
    KAFFINITY AffinityMask;
    KPRIORITY BasePriority;
    ULONG_PTR UniqueProcessId;
    ULONG_PTR InheritedFromUniqueProcessId;
    };

enum ADDRESS_MODE
    {
    AddrMode1616,
    AddrMode1632,
    AddrModeReal,
    AddrModeFlat
    };

struct ADDRESS64
    {
    DWORD64      Offset;
    WORD         Segment;
    ADDRESS_MODE Mode;
    };

struct KDHELP64
    {
    DWORD64 Thread;
    DWORD   ThCallbackStack;
    DWORD   ThCallbackBStore;
    DWORD   NextCallback;
    DWORD   FramePointer;
    DWORD64 KiCallUserMode;
    DWORD64 KeUserCallbackDispatcher;
    DWORD64 SystemRangeStart;
    DWORD64 KiUserExceptionDispatcher;
    DWORD64 StackBase;
    DWORD64 StackLimit;
    DWORD64 Reserved[5];
    };

struct STACKFRAME64
    {
    ADDRESS64 AddrPC;
    ADDRESS64 AddrReturn;
    ADDRESS64 AddrFrame;
    ADDRESS64 AddrStack;
    ADDRESS64 AddrBStore;
    PVOID     FuncTableEntry;
    DWORD64   Params[4];
    BOOL      Far;
    BOOL      Virtual;
    DWORD64   Reserved[3];
    KDHELP64  KdHelp;
    };

struct WOW64_FLOATING_SAVE_AREA
    {
    DWORD ControlWord;
    DWORD StatusWord;
    DWORD TagWord;
    DWORD ErrorOffset;
    DWORD ErrorSelector;
    DWORD DataOffset;
    DWORD DataSelector;
    BYTE  RegisterArea[80];
    DWORD Cr0NpxState;
    };

#pragma pack (push, 4)

struct WOW64_CONTEXT
    {
    DWORD ContextFlags;

    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;

    WOW64_FLOATING_SAVE_AREA FloatSave;

    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;

    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;

    DWORD Ebp;
    DWORD Eip;
    DWORD SegCs;
    DWORD EFlags;
    DWORD Esp;
    DWORD SegSs;

    BYTE  ExtendedRegisters[512];
    };

#pragma pack (pop)

struct SYMBOL_INFO
    {
    ULONG   SizeOfStruct;
    ULONG   TypeIndex;
    ULONG64 Reserved[2];
    ULONG   info;
    ULONG   Size;
    ULONG64 ModBase;
    ULONG   Flags;
    ULONG64 Value;
    ULONG64 Address;
    ULONG   Register;
    ULONG   Scope;
    ULONG   Tag;
    ULONG   NameLen;
    ULONG   MaxNameLen;
    CHAR    Name[1];
    };

struct IMAGEHLP_LINE64
    {
    DWORD   SizeOfStruct;
    PVOID   Key;
    DWORD   LineNumber;
    PCHAR   FileName;
    DWORD64 Address;
    };

typedef bool    (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)   (HANDLE process, DWORD64 baseAddress, void* buffer, DWORD size, DWORD* bytesRead);
typedef void*   (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64) (HANDLE process, DWORD64 baseAddress);
typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)       (HANDLE process, DWORD64 address);
typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)     (HANDLE process, HANDLE thread, ADDRESS64* address);

typedef void (*unexpected_handler)();

#pragma pack (push, 4)

struct MINIDUMP_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    };

struct MINIDUMP_THREAD_EX_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    ULONG64  BackingStoreBase;
    ULONG64  BackingStoreEnd;
    };

struct MINIDUMP_MODULE_CALLBACK
    {
    wchar_t* FullPath;
    ULONG64  BaseOfImage;
    ULONG    SizeOfImage;
    ULONG    CheckSum;
    ULONG    TimeDateStamp;
    VS_FIXEDFILEINFO VersionInfo;
    void*    CvRecord;
    ULONG    SizeOfCvRecord;
    PVOID    MiscRecord;
    ULONG    SizeOfMiscRecord;
    };

struct MINIDUMP_INCLUDE_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    };

struct MINIDUMP_INCLUDE_MODULE_CALLBACK
    {
    ULONG64  BaseOfImage;
    };

struct MINIDUMP_MEMORY_INFO
    {
    ULONG64  BaseAddress;
    ULONG64  AllocationBase;
    ULONG32  AllocationProtect;
    ULONG32  __alignment1;
    ULONG64  RegionSize;
    ULONG32  State;
    ULONG32  Protect;
    ULONG32  Type;
    ULONG32  __alignment2;
    };

struct MINIDUMP_USER_STREAM
    {
    ULONG32  Type;
    ULONG    BufferSize;
    PVOID    Buffer;
    };

struct MINIDUMP_USER_STREAM_INFORMATION
    {
    ULONG                 UserStreamCount;
    MINIDUMP_USER_STREAM* UserStreamArray;
    };

struct MINIDUMP_CALLBACK_INPUT
    {
    ULONG    ProcessId;
    HANDLE   ProcessHandle;
    ULONG    CallbackType;

    union
        {
        MINIDUMP_THREAD_CALLBACK         Thread;
        MINIDUMP_THREAD_EX_CALLBACK      ThreadEx;
        MINIDUMP_MODULE_CALLBACK         Module;
        MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
        MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
        };
    };

struct MINIDUMP_CALLBACK_OUTPUT
    {
    union
        {
        ULONG ModuleWriteFlags;
        ULONG ThreadWriteFlags;
        ULONG SecondaryFlags;

        struct
            {
            ULONG64  MemoryBase;
            ULONG    MemorySize;
            };

        struct
            {
            unsigned CheckCancel;
            unsigned Cancel;
            };

        HANDLE Handle;
        };

    struct
        {
        MINIDUMP_MEMORY_INFO VmRegion;
        unsigned             Continue;
        };

    HRESULT Status;
    };

struct MINIDUMP_EXCEPTION_INFORMATION
    {
    DWORD               ThreadId;
    EXCEPTION_POINTERS* ExceptionPointers;
    unsigned            ClientPointers;
    };

typedef int (WINAPI* MINIDUMP_CALLBACK_ROUTINE) (void* param, MINIDUMP_CALLBACK_INPUT* input, MINIDUMP_CALLBACK_OUTPUT* output);

struct MINIDUMP_CALLBACK_INFORMATION
    {
    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
    void*                     CallbackParam;
    };

enum MINIDUMP_TYPE
    {
    MiniDumpNormal                         = 0x00000000,
    MiniDumpWithDataSegs                   = 0x00000001,
    MiniDumpWithFullMemory                 = 0x00000002,
    MiniDumpWithHandleData                 = 0x00000004,
    MiniDumpFilterMemory                   = 0x00000008,
    MiniDumpScanMemory                     = 0x00000010,
    MiniDumpWithUnloadedModules            = 0x00000020,
    MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
    MiniDumpFilterModulePaths              = 0x00000080,
    MiniDumpWithProcessThreadData          = 0x00000100,
    MiniDumpWithPrivateReadWriteMemory     = 0x00000200,
    MiniDumpWithoutOptionalData            = 0x00000400,
    MiniDumpWithFullMemoryInfo             = 0x00000800,
    MiniDumpWithThreadInfo                 = 0x00001000,
    MiniDumpWithCodeSegs                   = 0x00002000,
    MiniDumpWithoutAuxiliaryState          = 0x00004000,
    MiniDumpWithFullAuxiliaryState         = 0x00008000,
    MiniDumpWithPrivateWriteCopyMemory     = 0x00010000,
    MiniDumpIgnoreInaccessibleMemory       = 0x00020000,
    MiniDumpWithTokenInformation           = 0x00040000
    };

#pragma pack (pop)

#define FOREGROUND_BLACK         ( 0                                                         )
#define FOREGROUND_CYAN          ( FOREGROUND_BLUE       | FOREGROUND_GREEN                  )
#define FOREGROUND_MAGENTA       ( FOREGROUND_BLUE       | FOREGROUND_RED                    )
#define FOREGROUND_DARKYELLOW    ( FOREGROUND_GREEN      | FOREGROUND_RED                    )
#define FOREGROUND_LIGHTGRAY     ( FOREGROUND_BLUE       | FOREGROUND_GREEN | FOREGROUND_RED )
#define FOREGROUND_DARKGRAY      (                         FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTBLUE     ( FOREGROUND_BLUE       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTGREEN    ( FOREGROUND_GREEN      | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTCYAN     ( FOREGROUND_CYAN       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTRED      ( FOREGROUND_RED        | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTMAGENTA  ( FOREGROUND_MAGENTA    | FOREGROUND_INTENSITY              )
#define FOREGROUND_YELLOW        ( FOREGROUND_DARKYELLOW | FOREGROUND_INTENSITY              )
#define FOREGROUND_WHITE         ( FOREGROUND_LIGHTGRAY  | FOREGROUND_INTENSITY              )

#define BACKGROUND_BLACK         ( 0                                                         )
#define BACKGROUND_CYAN          ( BACKGROUND_BLUE       | BACKGROUND_GREEN                  )
#define BACKGROUND_MAGENTA       ( BACKGROUND_BLUE       | BACKGROUND_RED                    )
#define BACKGROUND_DARKYELLOW    ( BACKGROUND_GREEN      | BACKGROUND_RED                    )
#define BACKGROUND_GRAY          ( BACKGROUND_BLUE       | BACKGROUND_GREEN | BACKGROUND_RED )
#define BACKGROUND_DARKGRAY      (                         BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTBLUE     ( BACKGROUND_BLUE       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTGREEN    ( BACKGROUND_GREEN      | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTCYAN     ( BACKGROUND_CYAN       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTRED      ( BACKGROUND_RED        | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTMAGENTA  ( BACKGROUND_MAGENTA    | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTYELLOW   ( BACKGROUND_DARKYELLOW | BACKGROUND_INTENSITY              )
#define BACKGROUND_WHITE         ( BACKGROUND_DARKGRAY   | BACKGROUND_INTENSITY              )

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ There are copies of MSVC compiler built-in predefined definitions, which are wrong in 64-bit mode.
//  So we have to override them. See: http://stackoverflow.com/questions/39113168
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)
                                                    //  MS ABI C++ Exception Layout
namespace Win32 {                                   //  ---------------------------
                                                    //
#pragma pack (push, 4)                              //   EXCEPTION_RECORD:
                                                    //  +==================================================+
struct ThrowInfo                                    //  |...                                               |
    {                                               //  |NumberParameters:        3, 4 or more             |
    __int32 attributes;                             //  |ExceptionInformation[0]: MS signature 0x19930520  |
    __int32 pmfnUnwind;                             //  |ExceptionInformation[1]: object* thrown           |
    __int32 pForwardCompat;                         //  |ExceptionInformation[2]: ThrowInfo* --------------+---+
    __int32 pCatchableTypeArray;                    //  |ExceptionInformation[3]: ImageBase (if params > 3)|   |
    };                                              //  +==================================================+   |
                                                    //                                                         |
struct CatchableTypeArray                           //        ThrowInfo:                                       |
    {                                               //        +======================================+ <-------+
    __int32 nCatchableTypes;                        //        |   ...                                |
    __int32 arrayOfCatchableTypes[];                //  +-----+-- pCatchableTypeArray (ptr/RVA)      |
    };                                              //  |     +======================================+
                                                    //  |
struct CatchableType                                //  |     CatchableTypeArray:
    {                                               //  +---> +======================================+
    __int32 properties;                             //        |   ...                                |
    __int32 pType;                                  //  +-----+-- arrayOfCatchableTypes[0] (ptr/RVA) |
    __int32 thisDisplacement[3]; // struct _PMD     //  |     +======================================+
    __int32 sizeOrOffset;                           //  |
    __int32 copyFunction;                           //  |     CatchableType:
    };                                              //  +---> +====================+
                                                    //        | ...                |        std::type_info:
#pragma pack (pop)                                  //        | pType (ptr/RVA) ---+------> +==================+
                                                    //        | ...                |        |type_info data    |
} // namespace Win32                                //        +====================+        |...               |
                                                    //                                      +==================+
#endif

// Similar to __CxxDetectRethrow(), see C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\crtsrc\vcruntime\frame.cpp:

#define _TX_MSC__CXX_DETECT_RETHROW( exc )                                     \
    (                                                                          \
    (exc)                                          &&                          \
    (exc) -> ExceptionCode    == EXCEPTION_CPP_MSC &&                          \
    (exc) -> NumberParameters >= 3                 &&                          \
                                                                               \
    ((exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3) && \
                                                                               \
    (exc) -> ExceptionInformation[2] == 0                                      \
    )

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ The corresponding structures for GCC
//
//  From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/unwind-cxx.h
//  See:  http://mentorembedded.github.io/cxx-abi/abi-eh.html#cxx-abi
//-----------------------------------------------------------------------------------------------------------------

#if defined (_GCC_VER)
                                                    // GCC ABI C++ Exception layout. A/B are ExceptionInformation[0].
namespace ABI {                                     // --------------------------------------------------------------
                                                    //
struct __cxa_exception                              // Case A: "_Unwind_Exception* A" is undependent exception:
    {                                               // --------------------------------------------------------
    union {                                         //
        struct                                      //           __cxa_exception:           std::type_info:
            {                                       //       -*--+====================+     +==================+
            ::std::type_info* exceptionType;        //        ^  |exceptionType* -----+---->|type_info data    |
            void (*exceptionDestructor)(void*);     //        |  |...                 |     |...               |
            };                                      //       -1  |                    |     +==================+
        struct                                      //        |  |                    |
            {                                       // A >----|--+--------------------+
            __cxa_exception*  primaryException;     //     |  |  |unwindHeader        |
            void (*padding)();                      //    +1  |  |                    |
            };                                      //     |  |  |                    |
        };                                          //     V  |  |                    |
                                                    //    -*---  +====================+
    std::unexpected_handler   unexpectedHandler;    //           |object              |
    std::terminate_handler    terminateHandler;     //           +--------------------+
                                                    //
    __cxa_exception*          nextException;        // Case B: "_Unwind_Exception* B" is dependent exception
    int                       handlerCount;         // (unwindHeader.exception_class & 1 != 0):
    int                       handlerSwitchValue;   // -----------------------------------------------------
    const unsigned char*      actionRecord;         //
    const unsigned char*      languageSpecificData; //           __cxa_exception:               __cxa_exception:
    void*                     catchTemp;            //       -*--+====================+     -*--+=================+
    void*                     adjustedPtr;          //        ^  |primaryException* --+--    ^  |exceptionType*   |
                                                    //        |  |...                 |  \   |  |...              |
    _Unwind_Exception         unwindHeader;         //       -1  |                    |  |   |  |                 |
    };                                              //        |  |                    |  |   |  |                 |
                                                    // B >----|--+--------------------+  |  -1  +-----------------+
struct __cxa_eh_globals                             //     |  |  |unwindHeader        |  |   |  |unwindHeader     |
    {                                               //    +1  |  |                    |  |   |  |                 |
    __cxa_exception* caughtExceptions;              //     |  |  |                    |  |   |  |                 |
    unsigned int     uncaughtExceptions;            //     V  |  |                    |  \   |  |                 |
    };                                              //    -*---  +====================+   -->*--+=================+
                                                    //           |...                 |         |object           |
} // namespace ABI                                  //           .                    .         |                 |
                                                    //                                          +-----------------+

extern "C" ABI::__cxa_eh_globals* __cxa_get_globals();

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{ Hand-made IAT.
//  Some IDEs don't link with these libs by default in console projects, so do sunrise by hand. :(
//-----------------------------------------------------------------------------------------------------------------

// Hand-made DLLIMPORT helpers

#define _TX_DLLIMPORT(     lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, true)

#define _TX_DLLIMPORT_OPT( lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, false)

#define _TX_DLLIMPORT_CRT( lib, retval, name, params ) \
     retval (      * name) params = (retval (      *) params) _txDllImport (lib ".dll", #name, false)

typedef void (*_tx_FARPROC)();

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required = true);

//-----------------------------------------------------------------------------------------------------------------

namespace Win32 {

_TX_DLLIMPORT     ("GDI32",    HDC,      CreateCompatibleDC,            (HDC dc));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateCompatibleBitmap,        (HDC dc, int width, int height));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetStockObject,                (int object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  SelectObject,                  (HDC dc, HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetCurrentObject,              (HDC dc, unsigned objectType));
_TX_DLLIMPORT     ("GDI32",    int,      GetObjectA,                    (HGDIOBJ obj, int bufsize, void* buffer));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GetObjectType,                 (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteDC,                      (HDC dc));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteObject,                  (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetTextColor,                  (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetBkColor,                    (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    int,      SetBkMode,                     (HDC dc, int bkMode));
_TX_DLLIMPORT     ("GDI32",    HFONT,    CreateFontA,                   (int height, int width, int escapement, int orientation,
                                                                         int weight, DWORD italic, DWORD underline, DWORD strikeout,
                                                                         DWORD charSet, DWORD outputPrec, DWORD clipPrec,
                                                                         DWORD quality, DWORD pitchAndFamily, const char face[]));
_TX_DLLIMPORT     ("GDI32",    int,      EnumFontFamiliesExA,           (HDC dc, LPLOGFONT logFont, FONTENUMPROC enumProc,
                                                                         LPARAM lParam, DWORD reserved));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetPixel,                      (HDC dc, int x, int y, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, GetPixel,                      (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    HPEN,     CreatePen,                     (int penStyle, int width, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    HBRUSH,   CreateSolidBrush,              (COLORREF color));
_TX_DLLIMPORT     ("GDI32",    bool,     MoveToEx,                      (HDC dc, int x, int y, POINT* point));
_TX_DLLIMPORT     ("GDI32",    bool,     LineTo,                        (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    bool,     Polygon,                       (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Polyline,                      (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     PolyBezier,                    (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Rectangle,                     (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     RoundRect,                     (HDC dc, int x0, int y0, int x1, int y1, int sizeX, int sizeY));
_TX_DLLIMPORT     ("GDI32",    bool,     Ellipse,                       (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     Arc,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Pie,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Chord,                         (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     TextOutA,                      (HDC dc, int x, int y, const char string[], int length));
_TX_DLLIMPORT     ("GDI32",    UINT,     SetTextAlign,                  (HDC dc, unsigned mode));
_TX_DLLIMPORT     ("GDI32",    bool,     GetTextExtentPoint32A,         (HDC dc, const char string[], int length, SIZE* size));
_TX_DLLIMPORT     ("GDI32",    bool,     ExtFloodFill,                  (HDC dc, int x, int y, COLORREF color, unsigned type));
_TX_DLLIMPORT     ("GDI32",    bool,     BitBlt,                        (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src,  int xSrc,  int ySrc,  DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     StretchBlt,                    (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src, int xSrc, int ySrc, int wSrc, int hSrc, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     PlgBlt,                        (HDC dest, const POINT* parallelogram,
                                                                         HDC src, int xSrc, int ySrc, int width, int height,
                                                                         HBITMAP mask, int xMask, int yMask));
_TX_DLLIMPORT     ("GDI32",    int,      SetDIBitsToDevice,             (HDC dc, int xDest, int yDest, DWORD width, DWORD height,
                                                                         int xSrc, int ySrc, unsigned startLine, unsigned numLines,
                                                                         const void* data, const BITMAPINFO* info, unsigned colorUse));
_TX_DLLIMPORT     ("GDI32",    int,      GetDIBits,                     (HDC hdc, HBITMAP hbmp, unsigned uStartScan, unsigned cScanLines,
                                                                         void* lpvBits, BITMAPINFO* lpbi, unsigned usage));
_TX_DLLIMPORT     ("GDI32",    bool,     PatBlt,                        (HDC dc, int x0, int y0, int width, int height, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    int,      SetROP2,                       (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    int,      SetStretchBltMode,             (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GdiSetBatchLimit,              (DWORD limit));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateDIBSection,              (HDC dc, const BITMAPINFO* bmInfo, unsigned colorUsage, void **vBits,
                                                                         HANDLE section, DWORD offset));

_TX_DLLIMPORT     ("User32",   int,      DrawTextA,                     (HDC dc, const char text[], int length, RECT* rect, unsigned format));
_TX_DLLIMPORT     ("User32",   HANDLE,   LoadImageA,                    (HINSTANCE inst, const char name[], unsigned type,
                                                                        int sizex, int sizey, unsigned mode));
_TX_DLLIMPORT_OPT ("User32",   bool,     IsHungAppWindow,               (HWND wnd));
_TX_DLLIMPORT_OPT ("User32",   HWND,     GhostWindowFromHungWindow,     (HWND wnd));

_TX_DLLIMPORT     ("WinMM",    bool,     PlaySound,                     (const char sound[], HMODULE mod, DWORD mode));

_TX_DLLIMPORT_OPT ("MSImg32",  bool,     TransparentBlt,                (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         unsigned transparentColor));
_TX_DLLIMPORT_OPT ("MSImg32",  bool,     AlphaBlend,                    (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         BLENDFUNCTION blending));

_TX_DLLIMPORT     ("Kernel32", void,     ExitProcess,                   (unsigned retcode));
_TX_DLLIMPORT     ("Kernel32", bool,     TerminateProcess,              (HANDLE process, unsigned retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalExit,                     (int retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalAppExitA,                 (unsigned action, const char message[]));
_TX_DLLIMPORT     ("Kernel32", HWND,     GetConsoleWindow,              (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetConsoleFont,                (HANDLE con, DWORD fontIndex));
_TX_DLLIMPORT_OPT ("Kernel32", DWORD,    GetNumberOfConsoleFonts,       (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFont,         (HANDLE con, bool maxWnd, CONSOLE_FONT_INFO*   curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", void,     RtlCaptureContext,             (CONTEXT* contextRecord));
_TX_DLLIMPORT_OPT ("Kernel32", USHORT,   RtlCaptureStackBackTrace,      (DWORD framesToSkip, DWORD framesToCapture, void** backTrace, DWORD* hash));
_TX_DLLIMPORT_OPT ("Kernel32", void*,    AddVectoredExceptionHandler,   (unsigned long firstHandler, PVECTORED_EXCEPTION_HANDLER handler));
_TX_DLLIMPORT_OPT ("Kernel32", unsigned, RemoveVectoredExceptionHandler,(void* handler));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetModuleHandleEx,             (DWORD flags, const char moduleName[], HMODULE* module));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     IsWow64Process,                (HANDLE process, int* isWow64Process));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     Wow64GetThreadContext,         (HANDLE thread, WOW64_CONTEXT* context));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetThreadStackGuarantee,       (unsigned long* stackSize));

_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoInitialize,                  (void*));
_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoCreateInstance,              (REFCLSID clsId, IUnknown*, DWORD, REFIID iId, PVOID* value));
_TX_DLLIMPORT     ("OLE32",    void,     CoUninitialize,                (void));

_TX_DLLIMPORT     ("Shell32",  HINSTANCE,ShellExecuteA,                 (HWND wnd, const char operation[], const char file[],
                                                                         const char parameters[], const char directory[], int showCmd));

_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIA,                      (const char    string[], const char    search[]));
_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIW,                      (const wchar_t string[], const wchar_t search[]));

_TX_DLLIMPORT_OPT ("NTDLL",    char*,    wine_get_version,              (void));
_TX_DLLIMPORT     ("NTDLL",    NTSTATUS, NtQueryInformationProcess,     (HANDLE process, int infoClass,
                                                                         void* processInfo, unsigned long szProcessInfo, unsigned long* szReturnInfo));

_TX_DLLIMPORT_CRT ("MSVCRT",   void,     exit,                          (int retcode));
_TX_DLLIMPORT_CRT ("MSVCRT",   void,     _cexit,                        (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _fpreset,                      (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _controlfp,                    (unsigned control, unsigned mask));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthread,                  (void (__cdecl* start_address) (void*), unsigned stack_size, void* arglist));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthreadex,                (void* security, unsigned stack_size, unsigned (__stdcall* start_address) (void*),
                                                                         void *arglist, unsigned init_flag, unsigned* thread_addr));
_TX_DLLIMPORT_CRT ("MSVCRT",   char*,    __unDName,                     (char* outStr, const char* mangledName, int outStrLen,
                                                                         void* (*mallocFunc) (size_t size), void (*freeFunc) (void *pointer),
                                                                         unsigned short flags));
_TX_DLLIMPORT_CRT ("MSVCRT",   unexpected_handler, set_unexpected,      (unexpected_handler handler));

_TX_DLLIMPORT_OPT ("OpenGL32", HDC,         wglGetCurrentDC,            (void));
_TX_DLLIMPORT_OPT ("OpenGL32", unsigned,    glGetError,                 (void));
_TX_DLLIMPORT_OPT ("Glu32",    const char*, gluErrorString,             (unsigned error));

_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     MiniDumpWriteDump,             (HANDLE process, DWORD processId, HANDLE file, MINIDUMP_TYPE dumpType,
                                                                         MINIDUMP_EXCEPTION_INFORMATION*   exceptionParam,
                                                                         MINIDUMP_USER_STREAM_INFORMATION* userStreamParam,
                                                                         MINIDUMP_CALLBACK_INFORMATION*    callbackParam));

_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("DbgHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
namespace MinGW {
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("MgwHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
} // namespace MinGW

} // namespace Win32

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal function prototypes, macros and constants
//  @name    Ïðîòîòèïû âíóòðåííèõ ôóíêöèé, ìàêðîñû è êîíñòàíòû
//=================================================================================================================
//! @{

const int        _TX_IDM_ABOUT                            =   40000,       // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
                 _TX_IDM_CONSOLE                          =   40001,
                 _TX_WM_CREATEWND                         =   0x7FF0,      // Ñîîáùåíèÿ äëÿ ñîçäàíèÿ/óíè÷òîæåíèÿ
                 _TX_WM_DESTROYWND                        =   0x7FF1;      // îêîí â ïîòîêå Canvas

//-----------------------------------------------------------------------------------------------------------------

int              _txInitialize();
void             _txCleanup();

HWND             _txCanvas_CreateWindow      (const SIZE* size);
inline bool      _txCanvas_OK() tx_nodiscard;

bool             _txCanvas_OnCREATE          (HWND wnd);
bool             _txCanvas_OnDESTROY         (HWND wnd);
bool             _txCanvas_OnCLOSE           (HWND);
bool             _txCanvas_OnPAINT           (HWND wnd);
bool             _txCanvas_OnKEYDOWN         (HWND wnd, WPARAM vk, LPARAM info);
bool             _txCanvas_OnCHAR            (HWND wnd, WPARAM ch, LPARAM info);
bool             _txCanvas_OnTIMER           (HWND wnd, WPARAM id);
bool             _txCanvas_OnMOUSEMOVE       (HWND wnd, WPARAM buttons, LPARAM coords);
bool             _txCanvas_OnMOUSELEAVE      (HWND wnd);
bool             _txCanvas_OnCREATEWND       (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnDESTROYWND      (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnCmdCONSOLE      (HWND wnd, WPARAM cmd);
bool             _txCanvas_OnCmdABOUT        (HWND wnd, WPARAM cmd);

unsigned WINAPI  _txCanvas_ThreadProc        (void* data);
LRESULT CALLBACK _txCanvas_WndProc           (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);

int              _txCanvas_SetRefreshLock    (int count);

HDC              _txBuffer_Create            (HWND wnd = NULL, const POINT* size = NULL, HBITMAP bitmap = NULL,
                                              RGBQUAD** pixels = NULL) tx_nodiscard;
bool             _txBuffer_Delete            (HDC* dc);
bool             _txBuffer_Select            (HGDIOBJ obj, HDC dc = txDC());

HWND             _txConsole_Attach();
bool             _txConsole_OK() tx_nodiscard;
bool             _txConsole_Detach           (bool activate);
bool             _txConsole_Draw             (HDC dc);
bool             _txConsole_SetUnicodeFont();

const char*       txRegisterClass            (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra);
HWND              txCreateExtraWindow        (CREATESTRUCT createData);
HICON            _txCreateTXIcon             (int size) tx_nodiscard;
int              _txSetFinishedText          (HWND wnd);
void             _txPauseBeforeTermination   (HWND canvas);
int              _txIsParentWaitable         (DWORD* parentPID = NULL) tx_nodiscard;
int              _txGetInput();

LRESULT CALLBACK _txPlayVideo_WndProc        (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
const char*      _txPlayVideo_FindVLC() tx_nodiscard;

bool             _txCreateShortcut           (const char shortcutName[],
                                              const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
                                              const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
                                              const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
                                              COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));

void*            _tx_DLGTEMPLATE_Create      (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                                              WORD controls, short x, short y, short cx, short cy,
                                              const char caption[], const char font[], WORD fontsize,
                                              const char menu[]) tx_nodiscard;

void*            _tx_DLGTEMPLATE_Add         (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                                              short x, short y, short cx, short cy,
                                              WORD id, const char wclass[], const char caption[]);

const char*      _txError                    (const char file[] = NULL, int line = 0, const char func[] = NULL, unsigned color = 0,
                                              const char msg[] = NULL, ...) tx_printfy (5);
const char*      _txProcessError             (const char file[], int line, const char func[], unsigned color,
                                              const char msg[], va_list args);
void             _txOnTerminate();
void             _txOnUnexpected();
void             _txOnPureCall();
void             _txOnNewHandlerAnsi();
int              _txOnNewHandler             (size_t size);
void             _txOnSignal                 (int signal = 0, int fpe = 0);
BOOL WINAPI      _txOnConsoleCtrlEvent       (DWORD type);
void             _txOnSecurityError          (int code, void*);
void             _txOnSecurityErrorAnsi      (const char* msg, void* ptr, int code);
int              _txOnMatherr                (_exception* except);
void             _txOnInvalidParam           (const wchar_t* expr, const wchar_t* func, const wchar_t* file,
                                              unsigned line, uintptr_t);
int              _txOnAllocHook              (int type, void* data, size_t size, int use, long request,
                                              const unsigned char* file, int line);
int              _txOnRTCFailure             (int type, const char* file, int line, const char* module, const char* format, ...) tx_printfy (5);
int              _txOnErrorReport            (int type, const char* text, int* ret);
int               tx_glGetError              (int setError = INT_MIN);

void             _txOnCExit();
void             _txOnExit                   (int      retcode);
void             _txOnFatalExit              (int      retcode);
void             _txOnExitProcess            (unsigned retcode);
void             _txOnFatalAppExitA          (unsigned action, const char message[]);
bool             _txOnTerminateProcess       (HANDLE process, unsigned retcode);
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
                 _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter);
void             _txWatchdogTerminator       (void* timeout);  // Only Arnold-type series are supported, not T1000

long WINAPI      _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc);
long WINAPI      _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc);
long             _txOnExceptionSEH           (EXCEPTION_POINTERS* exc, const char func[]);
intptr_t         _txDumpExceptionSEH         (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[]);
intptr_t         _txDumpExceptionObj         (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type);
intptr_t         _txDumpExceptionCPP         (char what[], intptr_t size, unsigned code = 0,
                                              unsigned params = 0, const ULONG_PTR info[] = NULL);

void             _txStackBackTrace           (const char file[] = "?", int line = 0, const char func[] = "?",
                                              bool readSource = true);
const char*      _txCaptureStackBackTrace    (int framesToSkip = 0, bool readSource = true,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
int              _txStackWalk                (int framesToSkip, size_t szCapture, void* capture[], unsigned long* backTraceHash,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
const char*      _txCaptureStackBackTraceTX  (int framesToSkip = 0, bool readSource = false);

const char*      _txSymPrintFromAddr         (void* addr = NULL, const char format[] = NULL, ...) tx_printfy (2);
bool             _txSymGetFromAddr           (void* addr, Win32::SYMBOL_INFO** symbol = NULL,
                                              Win32::IMAGEHLP_LINE64** line = NULL, const char** module = NULL,
                                              const char** source = NULL, int context = 2);
intptr_t         _txReadSource               (char buf[], intptr_t size, const char file[],
                                              int linStart = 0, int linEnd = INT_MIN, int linMark = INT_MIN);
bool             _txCreateMiniDump           (EXCEPTION_POINTERS* exc);

uintptr_t        _txSetProcAddress           (const char funcName[], uintptr_t newFunc, const char dllName[] = NULL,
                                              int useHotPatching = false, HMODULE module = NULL, bool debug = false);
bool             _txInDll() tx_nodiscard;
PROCESSENTRY32*  _txFindProcess              (unsigned pid = GetCurrentProcessId()) tx_nodiscard;
bool             _txKillProcess              (DWORD pid);
bool             _txIsBadReadPtr             (const void* address);
bool             _txCheckSourceCP            (int needCP = _TX_CODEPAGE, bool verbose = true);
bool             _txGetCommandLine           (wchar_t cmdLine[], size_t szCmdLine, unsigned pid = _getpid());
IMAGE_NT_HEADERS*_txGetNtHeaders             (HMODULE module = GetModuleHandle (NULL)) tx_nodiscard;
const char*      _txAppInfo() tx_nodiscard;

intptr_t         _tx_snprintf_s              (char stream[], intptr_t size, const char format[], ...) tx_printfy (3);
intptr_t         _tx_vsnprintf_s             (char stream[], intptr_t size, const char format[], va_list arg);
void              txReopenStdio();

#if defined (_CLANG_VER) && !defined (_MSC_VER)
void             _txLibCppDebugFunction      (std::__libcpp_debug_info const& info);
#endif

#if defined (__CYGWIN__)

int              _getch();
int              _putch (int ch);
int              _kbhit() tx_nodiscard;

#endif

//-----------------------------------------------------------------------------------------------------------------
// There are macros for __FILE__ and __LINE__ to work properly.

#if !defined (NDEBUG)

    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) && \
                                                     (assert (cond), true) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå."), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("Ïàðàìåòð \"%s\" íåâåðåí. Âîçìîæíî, ýòîò õîëñò íå ñîçäàí, " \
                                                                "èëè óæå óíè÷òîæåí, èëè íå çàãðóçèëàñü êàðòèíêà.", #dc), 1) )
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( (!(dc) &&                                           \
                                                     _TX_TXWINDOW_FAILED()) || _TX_HDC_FAILED (dc) )

#else
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define _TX_DEFAULT_HDC_FAILED(dc)         ( !(dc) &&                                            \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
#endif

//-----------------------------------------------------------------------------------------------------------------
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but MSVC rejects it. So sad. :'(

#if !defined (NDEBUG)
    #define  _TX_ON_DEBUG( code )              { code; }
#else
    #define  _TX_ON_DEBUG( code )              ;
#endif

//-----------------------------------------------------------------------------------------------------------------
// Invokes an error without location information. "$$" restores TX-related call location context

#define _TX_UNEXPECTED( ... )                  $$ _txError (NULL, 0, NULL, 0, ##__VA_ARGS__)

//-----------------------------------------------------------------------------------------------------------------
// Safe call of a function via its pointer

#define _TX_CALL(  func, param )               ( (func)? ((func) param) :       0 )
#define _TX_CALLv( func, param )               ( (func)? ((func) param) : (void)0 )

//-----------------------------------------------------------------------------------------------------------------
// This is a macro because cond is an expression and is not always a function. Lack of lambdas in pre-C++0x.

#define      _txWaitFor( cond, time )          { for (DWORD _t = GetTickCount() + (time); \
                                                      !(cond) && GetTickCount() < _t;     \
                                                      Sleep (_txWindowUpdateInterval)) ;  \
                                                 if  (!(cond))                            \
                                                      _txTrace (__FILE__, __LINE__, NULL, "WARNING: Timeout: " #cond "."); }
//-----------------------------------------------------------------------------------------------------------------
// Detouring in case of SEH mechanism

#define _txSetJmp()                            ( setjmp (_txDumpExceptionObjJmp) == 0 )

#define _txClearJmp()                          { *(unsigned long long*) _txDumpExceptionObjJmp = 0; }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal global data
//! @name    Âíóòðåííèå ãëîáàëüíûå äàííûå
//
//           Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
//           Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåð, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
//           Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
//           Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé, èëè êëàññ.
//=================================================================================================================
//! @{

int                          _txInitialized              = _TX_NOINIT || _txInitialize();

volatile const unsigned      _txCanaryFirst              = 0x776F656D; // A very system value

volatile unsigned            _txMainThreadId             = 0;          // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
volatile HANDLE              _txMainThread               = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà

volatile unsigned            _txCanvas_ThreadId          = 0;          // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
volatile HANDLE              _txCanvas_Thread            = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
volatile HWND                _txCanvas_Window            = NULL;       // Äåñêðèïòîð îêíà õîëñòà TXLib

HDC                          _txCanvas_BackBuf[2]        = {NULL,      // [0] Main TXLib in-memory DC, where user's pictures lies
                                                            NULL};     // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()

RGBQUAD*                     _txCanvas_Pixels            = NULL;       // Memory buffer of _txCanvas_BackBuf[0]

HBITMAP                      _txStockBitmap              = NULL;       // Equivalent of GetStockObject (BITMAP),
                                                                       // see https://devblogs.microsoft.com/oldnewthing/20100416-00/?p=14313

CRITICAL_SECTION             _txCanvas_LockBackBuf       = {0,-1};     // Prevent simultaneous access to back buffer, see txLock()

UINT_PTR                     _txCanvas_RefreshTimer      = 1;          // Timer ID to redraw TXLib window
volatile int                 _txCanvas_RefreshLock       = 0;          // Blocks auto on-timer canvas update, see txBegin/txEnd

::std::vector<HDC>*          _txCanvas_UserDCs           = NULL;       // List of DCs allocated, for auto-free

volatile bool                _txConsole_IsBlinking       = true;       // To blink or not to blink, that is the question.

bool                         _txConsole                  = false;      // Only first TXLib module in app can own the console
bool                         _txMain                     = false;      // First TXLib wnd opened (closing it terminates program)
bool                         _txIsDll                    = false;      // TXLib module is in DLL
volatile bool                _txRunning                  = false;      // main() is still running
volatile bool                _txExit                     = false;      // exit() is active

volatile POINT               _txMousePos                 = {-1,-1};    // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
volatile unsigned            _txMouseButtons             = 0;

volatile WNDPROC             _txAltWndProc               = NULL;       // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().

_tx_thread _txLoc            _txLoc::Cur                 = {};         // Execution point tracking and trace state, see "$" macro

volatile int                 _txErrors                   = 0;          // TX_ERROR calls sequental number
int                          _txOGLError                 = 0;          // Last OpenGL error when using tx_glGetError()
volatile long                _txSENumber                 = 0;          // SEH exceptions sequental number
volatile long                _txSEFatalNumber            = 0;          // SEH fatal exceptions sequental number
char                         _txDumpSE [_TX_BUFSIZE]     = "";         // SEH dump data area
char                         _txTraceSE[_TX_HUGEBUFSIZE] = "";         // Stack trace data area

LPTOP_LEVEL_EXCEPTION_FILTER _txPrevUEFilter             = NULL;       // Previous UnhandledExceptionFilter

jmp_buf                      _txDumpExceptionObjJmp      = {};         // Hook for _txDumpExceptionObj

const volatile uintptr_t     _txForceImport[]            = { (uintptr_t) ::TerminateProcess,              (uintptr_t) ::ExitProcess,
                                                             (uintptr_t) ::FatalExit,                     (uintptr_t) ::FatalAppExitA,
                                                             (uintptr_t) ::exit,                          (uintptr_t) Win32::_controlfp,
                                                             (uintptr_t) Win32::Polyline,                 (uintptr_t) Win32::PolyBezier,
                                                             (uintptr_t) Win32::RoundRect,                (uintptr_t) Win32::RemoveVectoredExceptionHandler,
                                                             (uintptr_t) Win32::PlgBlt,                   (uintptr_t) Win32::RtlCaptureStackBackTrace,
                                                             (uintptr_t) Win32::SymInitialize,            (uintptr_t) Win32::MinGW::SymInitialize,
                                                             (uintptr_t) Win32::SymSetOptions,            (uintptr_t) Win32::MinGW::SymSetOptions,
                                                             (uintptr_t) Win32::SymGetLineFromAddr64,     (uintptr_t) Win32::MinGW::SymGetLineFromAddr64,
                                                             (uintptr_t) Win32::SymFromAddr,              (uintptr_t) Win32::MinGW::SymFromAddr,
                                                             (uintptr_t) Win32::SymCleanup,               (uintptr_t) Win32::MinGW::SymCleanup,
                                                             (uintptr_t) Win32::SymGetModuleBase64,       (uintptr_t) Win32::MinGW::SymGetModuleBase64,
                                                             (uintptr_t) Win32::SymFunctionTableAccess64, (uintptr_t) Win32::MinGW::SymFunctionTableAccess64,
                                                             (uintptr_t) Win32::StackWalk64,              (uintptr_t) Win32::MinGW::StackWalk64,
                                                             (uintptr_t) Win32::StrStrIA,                 (uintptr_t) Win32::Wow64GetThreadContext };

volatile const unsigned      _txCanaryLast               = 0x5E2E2E5E; // Another very system value

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib engine init/check/cleanup
//! @name    Èíèöèàëèçàöèÿ/ïðîâåðêà/çàâåðøåíèå TXLib
//=================================================================================================================
//! @{

//-----------------------------------------------------------------------------------------------------------------
//{          Early initialization
//-----------------------------------------------------------------------------------------------------------------

int _txInitialize()
    {
    if (_txInitialized) return 1;
    _txInitialized = 1;

    #if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)  // See http://msdn.microsoft.com/en-us/library/w2fhc9a3%28v=vs.90%29.aspx
    _CrtSetBreakAlloc (_TX_ALLOC_BREAK);                 // and http://support.microsoft.com/ru-ru/kb/151585
    #endif

    #if defined (_TX_ALLOW_TRACE)
    _txLocLvlSet (1);
    #endif

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
                                     "compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

    _txMainThreadId = GetCurrentThreadId();
    _txMainThread   = OpenThread (THREAD_ALL_ACCESS, false, _txMainThreadId);

$3  _txIsDll = _txInDll();

$   if (!_txIsDll)
        {
$       _txConsole = ! FindAtom ("_txConsole");
$       (void)          AddAtom ("_txConsole");
        }

$   if (_txConsole)
        {
$       _txCheckSourceCP (_TX_CODEPAGE, true);

$       unsigned long stackSize = _TX_STACKSIZE;
$       _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$       _txOnSignal();

$       if (!*_txLogName)
            {$ _tx_snprintf_s (_txLogName, sizeof (_txLogName) - 1, "%s.log", txGetModuleFileName()); }

$       if (!_txIsDll)
            {
$           _TX_CALL  (Win32::AddVectoredExceptionHandler, (1, (PVECTORED_EXCEPTION_HANDLER)  _txVectoredExceptionHandler));
$           _txPrevUEFilter = SetUnhandledExceptionFilter  (   (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter);
            }

$       ::std::set_terminate             (_txOnTerminate);
$       ::std::set_new_handler           (_txOnNewHandlerAnsi);
$       _TX_CALL (Win32::set_unexpected, (_txOnUnexpected));

        #if defined (_CLANG_VER) && !defined (_MSC_VER)
$       ::std::__libcpp_debug_function = _txLibCppDebugFunction;
        #endif

$       SetConsoleCtrlHandler (_txOnConsoleCtrlEvent, true);

$       SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);

        #if defined (_MSC_VER)

$       _set_printf_count_output (1);

$       _set_new_handler (_txOnNewHandler);
$       _set_new_mode (1);

        #if !defined (_CLANG_VER)

$       _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$       _CrtSetAllocHook (_txOnAllocHook);

$       unsigned mode = _CRTDBG_MODE_FILE;
$       if (_CrtSetReportHook2 (_CRT_RPTHOOK_INSTALL, (_CRT_REPORT_HOOK) _txOnErrorReport) > 0) mode = 0;

$       _CrtSetReportMode (_CRT_WARN,   _CRTDBG_MODE_DEBUG | mode);
$       _CrtSetReportMode (_CRT_ERROR,  _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportFile (_CRT_WARN,   _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ERROR,  _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);

        #endif

$       _set_abort_behavior (_WRITE_ABORT_MSG, _WRITE_ABORT_MSG);
$       _set_abort_behavior (0,                _CALL_REPORTFAULT);

$       _RTC_SetErrorFunc              (_txOnRTCFailure);
$       _set_purecall_handler          (_txOnPureCall);
$       _set_invalid_parameter_handler (_txOnInvalidParam);

        #endif

        #if defined (__STDC_LIB_EXT1__)
$       ::std::set_constraint_handler_s (_txOnSecurityErrorAnsi);
        #endif

        #if !defined (__CYGWIN__) && defined (_GCC_VER) && (_GCC_VER >= 530) && !defined (i386)
$       __setusermatherr (_txOnMatherr);
        #endif

        #if !defined (__CYGWIN__)
$       _set_error_mode (_OUT_TO_MSGBOX | _OUT_TO_STDERR);
        #endif

$       HWND console = _txConsole_Attach();
$       SetWindowTextA (console, txGetModuleFileName (false));
        }

$   InitializeCriticalSection (&_txCanvas_LockBackBuf);

$   _txSetProcAddress ("ExitProcess",                 (uintptr_t) _txOnExitProcess,                 "KERNEL32.DLL");
$   _txSetProcAddress ("TerminateProcess",            (uintptr_t) _txOnTerminateProcess,            "KERNEL32.DLL");
$   _txSetProcAddress ("FatalExit",                   (uintptr_t) _txOnFatalExit,                   "KERNEL32.DLL");
$   _txSetProcAddress ("FatalAppExitA",               (uintptr_t) _txOnFatalAppExitA,               "KERNEL32.DLL");
$   _txSetProcAddress ("UnhandledExceptionFilter",    (uintptr_t) _txUnhandledExceptionFilter,      "KERNEL32.DLL", true);
$   _txSetProcAddress ("SetUnhandledExceptionFilter", (uintptr_t) _txOnSetUnhandledExceptionFilter, "KERNEL32.DLL");
$   _txSetProcAddress ("exit",                        (uintptr_t) _txOnExit);
$   _txSetProcAddress ("_cexit",                      (uintptr_t) _txOnCExit);

$   atexit (_txCleanup);

$   if (_txConsole)
        {
$       txSetConsoleAttr (FOREGROUND_LIGHTGRAY);

$       tx_fpreset();

$       srand ((unsigned) time (NULL));

$       SetLastError (0);
$       errno = 0;

        #if !defined (__CYGWIN__)
$       _doserrno = 0;
        #endif
        }

$   HDC dc = Win32::CreateCompatibleDC (NULL); dc asserted;
$   _txStockBitmap = (HBITMAP) Win32::SelectObject (dc, Win32::CreateCompatibleBitmap (dc, 1, 1)); _txStockBitmap asserted;
$   Win32::DeleteObject (Win32::SelectObject (dc, _txStockBitmap)) asserted;
$   Win32::DeleteDC (dc) asserted;

$   return 1;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCheckSourceCP (int needCP /*= _TX_CODEPAGE*/, bool verbose /*= true*/)
    {
$3  const char* sCodePage = NULL;
$   int codePage = 0;

$   switch (((unsigned const char*) "À") [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }

$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please

$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }

$   return (codePage == needCP);
    }

//-----------------------------------------------------------------------------------------------------------------

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;

    static char dllPaths [2][MAX_PATH] = {"", ""};

    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";

        // dllPaths[0] is relative to the TX Setup directory stored in the Registry

        char* path = dllPaths[0];

        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);

        // dllPaths[1] is relative to TXib.h file used in compilation

        path = dllPaths[1];

        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }

        if (char* dir = strrchr (path, '\\')) *dir = 0;

        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }

    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);

    if (arch)
        {
        assert (arch >= dllFileName);

        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));

        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }

    HMODULE   dll = GetModuleHandle (dllFileName);

    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);

    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);

        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);

        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }

    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);

    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;

    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);

    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè
#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
    // ïðè âûõîäå èç ôóíêöèè è ñòðîêà â íåì, ñîîòâåòñòâåííî, òîæå. Àäðåñ íåñòàòè÷åñêèõ ïåðåìåííûõ ïåðåäàâàòü
    // ñèíòàêñè÷åñêè ìîæíî, íî âåäåò ê ñåðüåçíûì îøèáêàì.
    //-------------------------------------------------------------------------------------------------------------
 
    return dlg.str;
    }
 
//}
//=================================================================================================================
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          TXLIB IMPLEMENTATION
//           Ðåàëèçàöèÿ ôóíêöèé áèáëèîòåêè
//=================================================================================================================
 
//=================================================================================================================
//{          DLL functions import, missing types definitions
//=================================================================================================================
 
namespace Win32 {
 
//-----------------------------------------------------------------------------------------------------------------
//{ Some of structs, consts and interfaces aren't defined in MinGW some early headers.
//  Copied from Windows SDK 7.0a.
//-----------------------------------------------------------------------------------------------------------------
 
#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA                             0x01
#endif
 
#ifndef SMTO_ERRORONEXIT
#define SMTO_ERRORONEXIT                         0x0020
#endif
 
#ifndef NT_CONSOLE_PROPS_SIG
#define NT_CONSOLE_PROPS_SIG                     0xA0000002
#endif
 
#ifndef NIIF_INFO
#define NIIF_INFO                                0x00000001
#define NIIF_WARNING                             0x00000002
#define NIIF_ERROR                               0x00000003
#endif
 
#ifndef NIF_INFO
#define NIF_STATE                                0x00000008
#define NIF_INFO                                 0x00000010
#endif
 
#ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
#define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS   0x00000004
#endif
 
#ifndef SYMOPT_CASE_INSENSITIVE
#define SYMOPT_CASE_INSENSITIVE                  0x00000001
#define SYMOPT_UNDNAME                           0x00000002
#define SYMOPT_DEFERRED_LOADS                    0x00000004
#define SYMOPT_NO_CPP                            0x00000008
#define SYMOPT_LOAD_LINES                        0x00000010
#define SYMOPT_OMAP_FIND_NEAREST                 0x00000020
#define SYMOPT_LOAD_ANYTHING                     0x00000040
#define SYMOPT_IGNORE_CVREC                      0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS              0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS              0x00000200
#define SYMOPT_EXACT_SYMBOLS                     0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS            0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH                 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES             0x00002000
#define SYMOPT_PUBLICS_ONLY                      0x00004000
#define SYMOPT_NO_PUBLICS                        0x00008000
#define SYMOPT_AUTO_PUBLICS                      0x00010000
#define SYMOPT_NO_IMAGE_SEARCH                   0x00020000
#define SYMOPT_SECURE                            0x00040000
#define SYMOPT_NO_PROMPTS                        0x00080000
#define SYMOPT_ALLOW_ZERO_ADDRESS                0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT         0x02000000
#define SYMOPT_FAVOR_COMPRESSED                  0x00800000
#define SYMOPT_FLAT_DIRECTORY                    0x00400000
#define SYMOPT_IGNORE_IMAGEDIR                   0x00200000
#define SYMOPT_OVERWRITE                         0x00100000
#define SYMOPT_DEBUG                             0x80000000
#endif
 
// SEH exception codes. For GCC, see http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 64-66.
 
#ifndef STATUS_POSSIBLE_DEADLOCK
#define STATUS_POSSIBLE_DEADLOCK                 0xC0000194
#endif
 
#ifndef STATUS_FLOAT_MULTIPLE_FAULTS
#define STATUS_FLOAT_MULTIPLE_FAULTS             0xC00002B4
#endif
 
#ifndef STATUS_STACK_BUFFER_OVERRUN
#define STATUS_STACK_BUFFER_OVERRUN              0xC0000409
#endif
 
#ifndef STATUS_ASSERTION_FAILURE
#define STATUS_ASSERTION_FAILURE                 0xC0000420
#endif
 
#ifndef STATUS_WX86_BREAKPOINT
#define STATUS_WX86_BREAKPOINT                   0x4000001F
#endif
 
#ifndef DBG_PRINTEXCEPTION_C
#define DBG_PRINTEXCEPTION_C                     0x40010006  // OutputDebugStringA() call
#endif
 
#ifndef DBG_PRINTEXCEPTION_WIDE_C
#define DBG_PRINTEXCEPTION_WIDE_C                0x4001000A  // OutputDebugStringW() call
#endif
 
#ifndef DBG_THREAD_NAME
#define DBG_THREAD_NAME                          0x406D1388
#endif
 
#define EXCEPTION_CPP_MSC                        0xE06D7363  // '?msc'
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1       0x19930520  // '?msc' version magic, see ehdata.h
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2       0x19930521  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3       0x19930522  // '?msc' version magic
#define EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1  0x01994000  // '?msc' version magic
 
#define EXCEPTION_CPP_GCC                        0x20474343  // ' GCC'
#define EXCEPTION_CPP_GCC_UNWIND                 0x21474343  // '!GCC'
#define EXCEPTION_CPP_GCC_FORCED                 0x22474343  // '"GCC'
 
#define EXCEPTION_CLR_FAILURE                    0xE0434f4D  // 'àCOM'
 
#define EXCEPTION_CPP_BORLAND_BUILDER            0x0EEDFAE6  // Should never occur here
#define EXCEPTION_CPP_BORLAND_DELPHI             0x0EEDFADE  // Should never occur here
 
#pragma pack (push, 1)
 
struct CONSOLE_CURSOR_INFO
    {
    DWORD dwSize;
    BOOL bVisible;
    };
 
struct CONSOLE_FONT_INFO
    {
    DWORD nFont;
    COORD dwFontSize;
    };
 
struct CONSOLE_FONT_INFOEX
    {
    ULONG cbSize;
    DWORD nFont;
    COORD dwFontSize;
    UINT  FontFamily;
    UINT  FontWeight;
    WCHAR FaceName[LF_FACESIZE];
    };
 
struct DATABLOCK_HEADER
    {
    DWORD cbSize;
    DWORD dwSignature;
    };
 
struct NT_CONSOLE_PROPS
    {
    DATABLOCK_HEADER dbh;
 
    WORD  wFillAttribute;
    WORD  wPopupFillAttribute;
    COORD dwScreenBufferSize;
    COORD dwWindowSize;
    COORD dwWindowOrigin;
    DWORD nFont;
    DWORD nInputBufferSize;
    COORD dwFontSize;
    UINT  uFontFamily;
    UINT  uFontWeight;
    WCHAR FaceName[LF_FACESIZE];
    UINT  uCursorSize;
    BOOL  bFullScreen;
    BOOL  bQuickEdit;
    BOOL  bInsertMode;
    BOOL  bAutoPosition;
    UINT  uHistoryBufferSize;
    UINT  uNumberOfHistoryBuffers;
    BOOL  bHistoryNoDup;
 
    COLORREF ColorTable[16];
    };
 
#pragma pack (pop)
 
#undef  INTERFACE
#define INTERFACE IShellLinkDataList
 
DECLARE_INTERFACE_ (IShellLinkDataList, IUnknown)
    {
    // *** IUnknown methods ***
    STDMETHOD (QueryInterface)  (THIS_ REFIID iid, void** value)    _tx_override PURE;
    STDMETHOD_(ULONG, AddRef)   (THIS)                              _tx_override PURE;
    STDMETHOD_(ULONG, Release)  (THIS)                              _tx_override PURE;
 
    // *** IShellLinkDataList methods ***
    STDMETHOD (AddDataBlock)    (THIS_ void* dataBlock)             PURE;
    STDMETHOD (CopyDataBlock)   (THIS_ DWORD sig, void** dataBlock) PURE;
    STDMETHOD (RemoveDataBlock) (THIS_ DWORD sig)                   PURE;
    STDMETHOD (GetFlags)        (THIS_ DWORD* flags)                PURE;
    STDMETHOD (SetFlags)        (THIS_ DWORD  flags)                PURE;
 
    protected:
    virtual ~IShellLinkDataList();
    };
 
const GUID IID_IShellLink         = {0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID IID_IShellLinkDataList = {0x45e2b4ae, 0xb1c3, 0x11d0, {0xb9,0x2f,0x00,0xa0,0xc9,0x03,0x12,0xe1}};
const GUID IID_IPersistFile       = {0x0000010b, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
 
const GUID CLSID_SpVoice          = {0x96749377, 0x3391, 0x11d2, {0x9e,0xe3,0x00,0xc0,0x4f,0x79,0x73,0x96}};
const GUID IID_ISpVoice           = {0x6c44df74, 0x72b9, 0x4992, {0xa1,0xec,0xef,0x99,0x6e,0x04,0x22,0xd4}};
 
#undef  INTERFACE
 
typedef DWORD     NTSTATUS;
typedef ULONG_PTR KAFFINITY;
typedef LONG      KPRIORITY;
 
struct UNICODE_STRING
    {
    USHORT Length;
    USHORT MaximumLength;
    WCHAR* Buffer;
    };
 
struct RTL_USER_PROCESS_PARAMETERS
    {
    BYTE  Reserved1[16];
    void* Reserved2[10];
    UNICODE_STRING ImagePathName;
    UNICODE_STRING CommandLine;
    };
 
struct PEB
    {
    BYTE  Reserved1[2];
    BYTE  BeingDebugged;
    BYTE  Reserved2[1];
    void* Reserved3[2];
    void* Ldr;
    RTL_USER_PROCESS_PARAMETERS* ProcessParameters;
    void* Reserved4[3];
    void* AtlThunkSListPtr;
    void* Reserved5;
    ULONG Reserved6;
    void* Reserved7;
    ULONG Reserved8;
    ULONG AtlThunkSListPtr32;
    void* Reserved9[45];
    BYTE  Reserved10[96];
    void* PostProcessInitRoutine;
    BYTE  Reserved11[128];
    void* Reserved12[1];
    ULONG SessionId;
    };
 
struct PROCESS_BASIC_INFORMATION
    {
    NTSTATUS  ExitStatus;
    PEB*      PebBaseAddress;
    KAFFINITY AffinityMask;
    KPRIORITY BasePriority;
    ULONG_PTR UniqueProcessId;
    ULONG_PTR InheritedFromUniqueProcessId;
    };
 
enum ADDRESS_MODE
    {
    AddrMode1616,
    AddrMode1632,
    AddrModeReal,
    AddrModeFlat
    };
 
struct ADDRESS64
    {
    DWORD64      Offset;
    WORD         Segment;
    ADDRESS_MODE Mode;
    };
 
struct KDHELP64
    {
    DWORD64 Thread;
    DWORD   ThCallbackStack;
    DWORD   ThCallbackBStore;
    DWORD   NextCallback;
    DWORD   FramePointer;
    DWORD64 KiCallUserMode;
    DWORD64 KeUserCallbackDispatcher;
    DWORD64 SystemRangeStart;
    DWORD64 KiUserExceptionDispatcher;
    DWORD64 StackBase;
    DWORD64 StackLimit;
    DWORD64 Reserved[5];
    };
 
struct STACKFRAME64
    {
    ADDRESS64 AddrPC;
    ADDRESS64 AddrReturn;
    ADDRESS64 AddrFrame;
    ADDRESS64 AddrStack;
    ADDRESS64 AddrBStore;
    PVOID     FuncTableEntry;
    DWORD64   Params[4];
    BOOL      Far;
    BOOL      Virtual;
    DWORD64   Reserved[3];
    KDHELP64  KdHelp;
    };
 
struct WOW64_FLOATING_SAVE_AREA
    {
    DWORD ControlWord;
    DWORD StatusWord;
    DWORD TagWord;
    DWORD ErrorOffset;
    DWORD ErrorSelector;
    DWORD DataOffset;
    DWORD DataSelector;
    BYTE  RegisterArea[80];
    DWORD Cr0NpxState;
    };
 
#pragma pack (push, 4)
 
struct WOW64_CONTEXT
    {
    DWORD ContextFlags;
 
    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;
 
    WOW64_FLOATING_SAVE_AREA FloatSave;
 
    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;
 
    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;
 
    DWORD Ebp;
    DWORD Eip;
    DWORD SegCs;
    DWORD EFlags;
    DWORD Esp;
    DWORD SegSs;
 
    BYTE  ExtendedRegisters[512];
    };
 
#pragma pack (pop)
 
struct SYMBOL_INFO
    {
    ULONG   SizeOfStruct;
    ULONG   TypeIndex;
    ULONG64 Reserved[2];
    ULONG   info;
    ULONG   Size;
    ULONG64 ModBase;
    ULONG   Flags;
    ULONG64 Value;
    ULONG64 Address;
    ULONG   Register;
    ULONG   Scope;
    ULONG   Tag;
    ULONG   NameLen;
    ULONG   MaxNameLen;
    CHAR    Name[1];
    };
 
struct IMAGEHLP_LINE64
    {
    DWORD   SizeOfStruct;
    PVOID   Key;
    DWORD   LineNumber;
    PCHAR   FileName;
    DWORD64 Address;
    };
 
typedef bool    (__stdcall *PREAD_PROCESS_MEMORY_ROUTINE64)   (HANDLE process, DWORD64 baseAddress, void* buffer, DWORD size, DWORD* bytesRead);
typedef void*   (__stdcall *PFUNCTION_TABLE_ACCESS_ROUTINE64) (HANDLE process, DWORD64 baseAddress);
typedef DWORD64 (__stdcall *PGET_MODULE_BASE_ROUTINE64)       (HANDLE process, DWORD64 address);
typedef DWORD64 (__stdcall *PTRANSLATE_ADDRESS_ROUTINE64)     (HANDLE process, HANDLE thread, ADDRESS64* address);
 
typedef void (*unexpected_handler)();
 
#pragma pack (push, 4)
 
struct MINIDUMP_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    };
 
struct MINIDUMP_THREAD_EX_CALLBACK
    {
    ULONG    ThreadId;
    HANDLE   ThreadHandle;
    CONTEXT  Context;
    ULONG    SizeOfContext;
    ULONG64  StackBase;
    ULONG64  StackEnd;
    ULONG64  BackingStoreBase;
    ULONG64  BackingStoreEnd;
    };
 
struct MINIDUMP_MODULE_CALLBACK
    {
    wchar_t* FullPath;
    ULONG64  BaseOfImage;
    ULONG    SizeOfImage;
    ULONG    CheckSum;
    ULONG    TimeDateStamp;
    VS_FIXEDFILEINFO VersionInfo;
    void*    CvRecord;
    ULONG    SizeOfCvRecord;
    PVOID    MiscRecord;
    ULONG    SizeOfMiscRecord;
    };
 
struct MINIDUMP_INCLUDE_THREAD_CALLBACK
    {
    ULONG    ThreadId;
    };
 
struct MINIDUMP_INCLUDE_MODULE_CALLBACK
    {
    ULONG64  BaseOfImage;
    };
 
struct MINIDUMP_MEMORY_INFO
    {
    ULONG64  BaseAddress;
    ULONG64  AllocationBase;
    ULONG32  AllocationProtect;
    ULONG32  __alignment1;
    ULONG64  RegionSize;
    ULONG32  State;
    ULONG32  Protect;
    ULONG32  Type;
    ULONG32  __alignment2;
    };
 
struct MINIDUMP_USER_STREAM
    {
    ULONG32  Type;
    ULONG    BufferSize;
    PVOID    Buffer;
    };
 
struct MINIDUMP_USER_STREAM_INFORMATION
    {
    ULONG                 UserStreamCount;
    MINIDUMP_USER_STREAM* UserStreamArray;
    };
 
struct MINIDUMP_CALLBACK_INPUT
    {
    ULONG    ProcessId;
    HANDLE   ProcessHandle;
    ULONG    CallbackType;
 
    union
        {
        MINIDUMP_THREAD_CALLBACK         Thread;
        MINIDUMP_THREAD_EX_CALLBACK      ThreadEx;
        MINIDUMP_MODULE_CALLBACK         Module;
        MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
        MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
        };
    };
 
struct MINIDUMP_CALLBACK_OUTPUT
    {
    union
        {
        ULONG ModuleWriteFlags;
        ULONG ThreadWriteFlags;
        ULONG SecondaryFlags;
 
        struct
            {
            ULONG64  MemoryBase;
            ULONG    MemorySize;
            };
 
        struct
            {
            unsigned CheckCancel;
            unsigned Cancel;
            };
 
        HANDLE Handle;
        };
 
    struct
        {
        MINIDUMP_MEMORY_INFO VmRegion;
        unsigned             Continue;
        };
 
    HRESULT Status;
    };
 
struct MINIDUMP_EXCEPTION_INFORMATION
    {
    DWORD               ThreadId;
    EXCEPTION_POINTERS* ExceptionPointers;
    unsigned            ClientPointers;
    };
 
typedef int (WINAPI* MINIDUMP_CALLBACK_ROUTINE) (void* param, MINIDUMP_CALLBACK_INPUT* input, MINIDUMP_CALLBACK_OUTPUT* output);
 
struct MINIDUMP_CALLBACK_INFORMATION
    {
    MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
    void*                     CallbackParam;
    };
 
enum MINIDUMP_TYPE
    {
    MiniDumpNormal                         = 0x00000000,
    MiniDumpWithDataSegs                   = 0x00000001,
    MiniDumpWithFullMemory                 = 0x00000002,
    MiniDumpWithHandleData                 = 0x00000004,
    MiniDumpFilterMemory                   = 0x00000008,
    MiniDumpScanMemory                     = 0x00000010,
    MiniDumpWithUnloadedModules            = 0x00000020,
    MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
    MiniDumpFilterModulePaths              = 0x00000080,
    MiniDumpWithProcessThreadData          = 0x00000100,
    MiniDumpWithPrivateReadWriteMemory     = 0x00000200,
    MiniDumpWithoutOptionalData            = 0x00000400,
    MiniDumpWithFullMemoryInfo             = 0x00000800,
    MiniDumpWithThreadInfo                 = 0x00001000,
    MiniDumpWithCodeSegs                   = 0x00002000,
    MiniDumpWithoutAuxiliaryState          = 0x00004000,
    MiniDumpWithFullAuxiliaryState         = 0x00008000,
    MiniDumpWithPrivateWriteCopyMemory     = 0x00010000,
    MiniDumpIgnoreInaccessibleMemory       = 0x00020000,
    MiniDumpWithTokenInformation           = 0x00040000
    };
 
#pragma pack (pop)
 
#define FOREGROUND_BLACK         ( 0                                                         )
#define FOREGROUND_CYAN          ( FOREGROUND_BLUE       | FOREGROUND_GREEN                  )
#define FOREGROUND_MAGENTA       ( FOREGROUND_BLUE       | FOREGROUND_RED                    )
#define FOREGROUND_DARKYELLOW    ( FOREGROUND_GREEN      | FOREGROUND_RED                    )
#define FOREGROUND_LIGHTGRAY     ( FOREGROUND_BLUE       | FOREGROUND_GREEN | FOREGROUND_RED )
#define FOREGROUND_DARKGRAY      (                         FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTBLUE     ( FOREGROUND_BLUE       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTGREEN    ( FOREGROUND_GREEN      | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTCYAN     ( FOREGROUND_CYAN       | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTRED      ( FOREGROUND_RED        | FOREGROUND_INTENSITY              )
#define FOREGROUND_LIGHTMAGENTA  ( FOREGROUND_MAGENTA    | FOREGROUND_INTENSITY              )
#define FOREGROUND_YELLOW        ( FOREGROUND_DARKYELLOW | FOREGROUND_INTENSITY              )
#define FOREGROUND_WHITE         ( FOREGROUND_LIGHTGRAY  | FOREGROUND_INTENSITY              )
 
#define BACKGROUND_BLACK         ( 0                                                         )
#define BACKGROUND_CYAN          ( BACKGROUND_BLUE       | BACKGROUND_GREEN                  )
#define BACKGROUND_MAGENTA       ( BACKGROUND_BLUE       | BACKGROUND_RED                    )
#define BACKGROUND_DARKYELLOW    ( BACKGROUND_GREEN      | BACKGROUND_RED                    )
#define BACKGROUND_GRAY          ( BACKGROUND_BLUE       | BACKGROUND_GREEN | BACKGROUND_RED )
#define BACKGROUND_DARKGRAY      (                         BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTBLUE     ( BACKGROUND_BLUE       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTGREEN    ( BACKGROUND_GREEN      | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTCYAN     ( BACKGROUND_CYAN       | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTRED      ( BACKGROUND_RED        | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTMAGENTA  ( BACKGROUND_MAGENTA    | BACKGROUND_INTENSITY              )
#define BACKGROUND_LIGHTYELLOW   ( BACKGROUND_DARKYELLOW | BACKGROUND_INTENSITY              )
#define BACKGROUND_WHITE         ( BACKGROUND_DARKGRAY   | BACKGROUND_INTENSITY              )
 
} // namespace Win32
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{ There are copies of MSVC compiler built-in predefined definitions, which are wrong in 64-bit mode.
//  So we have to override them. See: http://stackoverflow.com/questions/39113168
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_MSC_VER)
                                                    //  MS ABI C++ Exception Layout
namespace Win32 {                                   //  ---------------------------
                                                    //
#pragma pack (push, 4)                              //   EXCEPTION_RECORD:
                                                    //  +==================================================+
struct ThrowInfo                                    //  |...                                               |
    {                                               //  |NumberParameters:        3, 4 or more             |
    __int32 attributes;                             //  |ExceptionInformation[0]: MS signature 0x19930520  |
    __int32 pmfnUnwind;                             //  |ExceptionInformation[1]: object* thrown           |
    __int32 pForwardCompat;                         //  |ExceptionInformation[2]: ThrowInfo* --------------+---+
    __int32 pCatchableTypeArray;                    //  |ExceptionInformation[3]: ImageBase (if params > 3)|   |
    };                                              //  +==================================================+   |
                                                    //                                                         |
struct CatchableTypeArray                           //        ThrowInfo:                                       |
    {                                               //        +======================================+ <-------+
    __int32 nCatchableTypes;                        //        |   ...                                |
    __int32 arrayOfCatchableTypes[];                //  +-----+-- pCatchableTypeArray (ptr/RVA)      |
    };                                              //  |     +======================================+
                                                    //  |
struct CatchableType                                //  |     CatchableTypeArray:
    {                                               //  +---> +======================================+
    __int32 properties;                             //        |   ...                                |
    __int32 pType;                                  //  +-----+-- arrayOfCatchableTypes[0] (ptr/RVA) |
    __int32 thisDisplacement[3]; // struct _PMD     //  |     +======================================+
    __int32 sizeOrOffset;                           //  |
    __int32 copyFunction;                           //  |     CatchableType:
    };                                              //  +---> +====================+
                                                    //        | ...                |        std::type_info:
#pragma pack (pop)                                  //        | pType (ptr/RVA) ---+------> +==================+
                                                    //        | ...                |        |type_info data    |
} // namespace Win32                                //        +====================+        |...               |
                                                    //                                      +==================+
#endif
 
// Similar to __CxxDetectRethrow(), see C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\crtsrc\vcruntime\frame.cpp:
 
#define _TX_MSC__CXX_DETECT_RETHROW( exc )                                     \
    (                                                                          \
    (exc)                                          &&                          \
    (exc) -> ExceptionCode    == EXCEPTION_CPP_MSC &&                          \
    (exc) -> NumberParameters >= 3                 &&                          \
                                                                               \
    ((exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||  \
     (exc)-> ExceptionInformation[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3) && \
                                                                               \
    (exc) -> ExceptionInformation[2] == 0                                      \
    )
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{ The corresponding structures for GCC
//
//  From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/unwind-cxx.h
//  See:  http://mentorembedded.github.io/cxx-abi/abi-eh.html#cxx-abi
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_GCC_VER)
                                                    // GCC ABI C++ Exception layout. A/B are ExceptionInformation[0].
namespace ABI {                                     // --------------------------------------------------------------
                                                    //
struct __cxa_exception                              // Case A: "_Unwind_Exception* A" is undependent exception:
    {                                               // --------------------------------------------------------
    union {                                         //
        struct                                      //           __cxa_exception:           std::type_info:
            {                                       //       -*--+====================+     +==================+
            ::std::type_info* exceptionType;        //        ^  |exceptionType* -----+---->|type_info data    |
            void (*exceptionDestructor)(void*);     //        |  |...                 |     |...               |
            };                                      //       -1  |                    |     +==================+
        struct                                      //        |  |                    |
            {                                       // A >----|--+--------------------+
            __cxa_exception*  primaryException;     //     |  |  |unwindHeader        |
            void (*padding)();                      //    +1  |  |                    |
            };                                      //     |  |  |                    |
        };                                          //     V  |  |                    |
                                                    //    -*---  +====================+
    std::unexpected_handler   unexpectedHandler;    //           |object              |
    std::terminate_handler    terminateHandler;     //           +--------------------+
                                                    //
    __cxa_exception*          nextException;        // Case B: "_Unwind_Exception* B" is dependent exception
    int                       handlerCount;         // (unwindHeader.exception_class & 1 != 0):
    int                       handlerSwitchValue;   // -----------------------------------------------------
    const unsigned char*      actionRecord;         //
    const unsigned char*      languageSpecificData; //           __cxa_exception:               __cxa_exception:
    void*                     catchTemp;            //       -*--+====================+     -*--+=================+
    void*                     adjustedPtr;          //        ^  |primaryException* --+--    ^  |exceptionType*   |
                                                    //        |  |...                 |  \   |  |...              |
    _Unwind_Exception         unwindHeader;         //       -1  |                    |  |   |  |                 |
    };                                              //        |  |                    |  |   |  |                 |
                                                    // B >----|--+--------------------+  |  -1  +-----------------+
struct __cxa_eh_globals                             //     |  |  |unwindHeader        |  |   |  |unwindHeader     |
    {                                               //    +1  |  |                    |  |   |  |                 |
    __cxa_exception* caughtExceptions;              //     |  |  |                    |  |   |  |                 |
    unsigned int     uncaughtExceptions;            //     V  |  |                    |  \   |  |                 |
    };                                              //    -*---  +====================+   -->*--+=================+
                                                    //           |...                 |         |object           |
} // namespace ABI                                  //           .                    .         |                 |
                                                    //                                          +-----------------+
 
extern "C" ABI::__cxa_eh_globals* __cxa_get_globals();
 
#endif
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{ Hand-made IAT.
//  Some IDEs don't link with these libs by default in console projects, so do sunrise by hand. :(
//-----------------------------------------------------------------------------------------------------------------
 
// Hand-made DLLIMPORT helpers
 
#define _TX_DLLIMPORT(     lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, true)
 
#define _TX_DLLIMPORT_OPT( lib, retval, name, params ) \
     retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, false)
 
#define _TX_DLLIMPORT_CRT( lib, retval, name, params ) \
     retval (      * name) params = (retval (      *) params) _txDllImport (lib ".dll", #name, false)
 
typedef void (*_tx_FARPROC)();
 
_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required = true);
 
//-----------------------------------------------------------------------------------------------------------------
 
namespace Win32 {
 
_TX_DLLIMPORT     ("GDI32",    HDC,      CreateCompatibleDC,            (HDC dc));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateCompatibleBitmap,        (HDC dc, int width, int height));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetStockObject,                (int object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  SelectObject,                  (HDC dc, HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    HGDIOBJ,  GetCurrentObject,              (HDC dc, unsigned objectType));
_TX_DLLIMPORT     ("GDI32",    int,      GetObjectA,                    (HGDIOBJ obj, int bufsize, void* buffer));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GetObjectType,                 (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteDC,                      (HDC dc));
_TX_DLLIMPORT     ("GDI32",    bool,     DeleteObject,                  (HGDIOBJ object));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetTextColor,                  (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetBkColor,                    (HDC dc, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    int,      SetBkMode,                     (HDC dc, int bkMode));
_TX_DLLIMPORT     ("GDI32",    HFONT,    CreateFontA,                   (int height, int width, int escapement, int orientation,
                                                                         int weight, DWORD italic, DWORD underline, DWORD strikeout,
                                                                         DWORD charSet, DWORD outputPrec, DWORD clipPrec,
                                                                         DWORD quality, DWORD pitchAndFamily, const char face[]));
_TX_DLLIMPORT     ("GDI32",    int,      EnumFontFamiliesExA,           (HDC dc, LPLOGFONT logFont, FONTENUMPROC enumProc,
                                                                         LPARAM lParam, DWORD reserved));
_TX_DLLIMPORT     ("GDI32",    COLORREF, SetPixel,                      (HDC dc, int x, int y, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    COLORREF, GetPixel,                      (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    HPEN,     CreatePen,                     (int penStyle, int width, COLORREF color));
_TX_DLLIMPORT     ("GDI32",    HBRUSH,   CreateSolidBrush,              (COLORREF color));
_TX_DLLIMPORT     ("GDI32",    bool,     MoveToEx,                      (HDC dc, int x, int y, POINT* point));
_TX_DLLIMPORT     ("GDI32",    bool,     LineTo,                        (HDC dc, int x, int y));
_TX_DLLIMPORT     ("GDI32",    bool,     Polygon,                       (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Polyline,                      (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     PolyBezier,                    (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT     ("GDI32",    bool,     Rectangle,                     (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     RoundRect,                     (HDC dc, int x0, int y0, int x1, int y1, int sizeX, int sizeY));
_TX_DLLIMPORT     ("GDI32",    bool,     Ellipse,                       (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT     ("GDI32",    bool,     Arc,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Pie,                           (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     Chord,                         (HDC dc, int x0, int y0, int x1, int y1,
                                                                         int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT     ("GDI32",    bool,     TextOutA,                      (HDC dc, int x, int y, const char string[], int length));
_TX_DLLIMPORT     ("GDI32",    UINT,     SetTextAlign,                  (HDC dc, unsigned mode));
_TX_DLLIMPORT     ("GDI32",    bool,     GetTextExtentPoint32A,         (HDC dc, const char string[], int length, SIZE* size));
_TX_DLLIMPORT     ("GDI32",    bool,     ExtFloodFill,                  (HDC dc, int x, int y, COLORREF color, unsigned type));
_TX_DLLIMPORT     ("GDI32",    bool,     BitBlt,                        (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src,  int xSrc,  int ySrc,  DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     StretchBlt,                    (HDC dest, int xDest, int yDest, int width, int height,
                                                                         HDC src, int xSrc, int ySrc, int wSrc, int hSrc, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    bool,     PlgBlt,                        (HDC dest, const POINT* parallelogram,
                                                                         HDC src, int xSrc, int ySrc, int width, int height,
                                                                         HBITMAP mask, int xMask, int yMask));
_TX_DLLIMPORT     ("GDI32",    int,      SetDIBitsToDevice,             (HDC dc, int xDest, int yDest, DWORD width, DWORD height,
                                                                         int xSrc, int ySrc, unsigned startLine, unsigned numLines,
                                                                         const void* data, const BITMAPINFO* info, unsigned colorUse));
_TX_DLLIMPORT     ("GDI32",    int,      GetDIBits,                     (HDC hdc, HBITMAP hbmp, unsigned uStartScan, unsigned cScanLines,
                                                                         void* lpvBits, BITMAPINFO* lpbi, unsigned usage));
_TX_DLLIMPORT     ("GDI32",    bool,     PatBlt,                        (HDC dc, int x0, int y0, int width, int height, DWORD rOp));
_TX_DLLIMPORT     ("GDI32",    int,      SetROP2,                       (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    int,      SetStretchBltMode,             (HDC dc, int mode));
_TX_DLLIMPORT     ("GDI32",    DWORD,    GdiSetBatchLimit,              (DWORD limit));
_TX_DLLIMPORT     ("GDI32",    HBITMAP,  CreateDIBSection,              (HDC dc, const BITMAPINFO* bmInfo, unsigned colorUsage, void **vBits,
                                                                         HANDLE section, DWORD offset));
 
_TX_DLLIMPORT     ("User32",   int,      DrawTextA,                     (HDC dc, const char text[], int length, RECT* rect, unsigned format));
_TX_DLLIMPORT     ("User32",   HANDLE,   LoadImageA,                    (HINSTANCE inst, const char name[], unsigned type,
                                                                        int sizex, int sizey, unsigned mode));
_TX_DLLIMPORT_OPT ("User32",   bool,     IsHungAppWindow,               (HWND wnd));
_TX_DLLIMPORT_OPT ("User32",   HWND,     GhostWindowFromHungWindow,     (HWND wnd));
 
_TX_DLLIMPORT     ("WinMM",    bool,     PlaySound,                     (const char sound[], HMODULE mod, DWORD mode));
 
_TX_DLLIMPORT_OPT ("MSImg32",  bool,     TransparentBlt,                (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         unsigned transparentColor));
_TX_DLLIMPORT_OPT ("MSImg32",  bool,     AlphaBlend,                    (HDC dest, int destX, int destY, int destWidth, int destHeight,
                                                                         HDC src,  int srcX,  int srcY,  int srcWidth,  int srcHeight,
                                                                         BLENDFUNCTION blending));
 
_TX_DLLIMPORT     ("Kernel32", void,     ExitProcess,                   (unsigned retcode));
_TX_DLLIMPORT     ("Kernel32", bool,     TerminateProcess,              (HANDLE process, unsigned retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalExit,                     (int retcode));
_TX_DLLIMPORT_OPT ("Kernel32", void,     FatalAppExitA,                 (unsigned action, const char message[]));
_TX_DLLIMPORT     ("Kernel32", HWND,     GetConsoleWindow,              (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetConsoleFont,                (HANDLE con, DWORD fontIndex));
_TX_DLLIMPORT_OPT ("Kernel32", DWORD,    GetNumberOfConsoleFonts,       (void));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFont,         (HANDLE con, bool maxWnd, CONSOLE_FONT_INFO*   curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetCurrentConsoleFontEx,       (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", void,     RtlCaptureContext,             (CONTEXT* contextRecord));
_TX_DLLIMPORT_OPT ("Kernel32", USHORT,   RtlCaptureStackBackTrace,      (DWORD framesToSkip, DWORD framesToCapture, void** backTrace, DWORD* hash));
_TX_DLLIMPORT_OPT ("Kernel32", void*,    AddVectoredExceptionHandler,   (unsigned long firstHandler, PVECTORED_EXCEPTION_HANDLER handler));
_TX_DLLIMPORT_OPT ("Kernel32", unsigned, RemoveVectoredExceptionHandler,(void* handler));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     GetModuleHandleEx,             (DWORD flags, const char moduleName[], HMODULE* module));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     IsWow64Process,                (HANDLE process, int* isWow64Process));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     Wow64GetThreadContext,         (HANDLE thread, WOW64_CONTEXT* context));
_TX_DLLIMPORT_OPT ("Kernel32", bool,     SetThreadStackGuarantee,       (unsigned long* stackSize));
 
_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoInitialize,                  (void*));
_TX_DLLIMPORT     ("OLE32",    HRESULT,  CoCreateInstance,              (REFCLSID clsId, IUnknown*, DWORD, REFIID iId, PVOID* value));
_TX_DLLIMPORT     ("OLE32",    void,     CoUninitialize,                (void));
 
_TX_DLLIMPORT     ("Shell32",  HINSTANCE,ShellExecuteA,                 (HWND wnd, const char operation[], const char file[],
                                                                         const char parameters[], const char directory[], int showCmd));
 
_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIA,                      (const char    string[], const char    search[]));
_TX_DLLIMPORT     ("ShlWAPI",  char*,    StrStrIW,                      (const wchar_t string[], const wchar_t search[]));
 
_TX_DLLIMPORT_OPT ("NTDLL",    char*,    wine_get_version,              (void));
_TX_DLLIMPORT     ("NTDLL",    NTSTATUS, NtQueryInformationProcess,     (HANDLE process, int infoClass,
                                                                         void* processInfo, unsigned long szProcessInfo, unsigned long* szReturnInfo));
 
_TX_DLLIMPORT_CRT ("MSVCRT",   void,     exit,                          (int retcode));
_TX_DLLIMPORT_CRT ("MSVCRT",   void,     _cexit,                        (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _fpreset,                      (void));
_TX_DLLIMPORT_CRT ("MSVCRT",   unsigned, _controlfp,                    (unsigned control, unsigned mask));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthread,                  (void (__cdecl* start_address) (void*), unsigned stack_size, void* arglist));
_TX_DLLIMPORT_CRT ("MSVCRT",   uintptr_t,_beginthreadex,                (void* security, unsigned stack_size, unsigned (__stdcall* start_address) (void*),
                                                                         void *arglist, unsigned init_flag, unsigned* thread_addr));
_TX_DLLIMPORT_CRT ("MSVCRT",   char*,    __unDName,                     (char* outStr, const char* mangledName, int outStrLen,
                                                                         void* (*mallocFunc) (size_t size), void (*freeFunc) (void *pointer),
                                                                         unsigned short flags));
_TX_DLLIMPORT_CRT ("MSVCRT",   unexpected_handler, set_unexpected,      (unexpected_handler handler));
 
_TX_DLLIMPORT_OPT ("OpenGL32", HDC,         wglGetCurrentDC,            (void));
_TX_DLLIMPORT_OPT ("OpenGL32", unsigned,    glGetError,                 (void));
_TX_DLLIMPORT_OPT ("Glu32",    const char*, gluErrorString,             (unsigned error));
 
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     MiniDumpWriteDump,             (HANDLE process, DWORD processId, HANDLE file, MINIDUMP_TYPE dumpType,
                                                                         MINIDUMP_EXCEPTION_INFORMATION*   exceptionParam,
                                                                         MINIDUMP_USER_STREAM_INFORMATION* userStreamParam,
                                                                         MINIDUMP_CALLBACK_INFORMATION*    callbackParam));
 
_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("DbgHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("DbgHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("DbgHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
namespace MinGW {
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD,    SymSetOptions,                 (DWORD options));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymInitialize,                 (HANDLE process, const char userSearchPath[], bool invadeProcess));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymFromAddr,                   (HANDLE process, DWORD64 addr, DWORD64* offset, SYMBOL_INFO*     symbol));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymGetLineFromAddr64,          (HANDLE process, DWORD64 addr, DWORD*   offset, IMAGEHLP_LINE64* line));
_TX_DLLIMPORT_OPT ("MgwHelp*", DWORD64,  SymGetModuleBase64,            (HANDLE process, DWORD64 addr));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     SymCleanup,                    (HANDLE process));
_TX_DLLIMPORT_OPT ("MgwHelp*", void*,    SymFunctionTableAccess64,      (HANDLE process, DWORD64 addrBase));
_TX_DLLIMPORT_OPT ("MgwHelp*", bool,     StackWalk64,                   (DWORD arch, HANDLE process, HANDLE thread, STACKFRAME64* frame, void* ctxRecord,
                                                                         PREAD_PROCESS_MEMORY_ROUTINE64   readMemoryFunc,
                                                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 tableAccessFunc,
                                                                         PGET_MODULE_BASE_ROUTINE64       getModuleBaseFunc,
                                                                         PTRANSLATE_ADDRESS_ROUTINE64     translateAddressFunc));
} // namespace MinGW
 
} // namespace Win32
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Internal function prototypes, macros and constants
//  @name    Ïðîòîòèïû âíóòðåííèõ ôóíêöèé, ìàêðîñû è êîíñòàíòû//=================================================================================================================
//! @{

const int        _TX_IDM_ABOUT                            =   40000,       // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
                 _TX_IDM_CONSOLE                          =   40001,
                 _TX_WM_CREATEWND                         =   0x7FF0,      // Ñîîáùåíèÿ äëÿ ñîçäàíèÿ/óíè÷òîæåíèÿ
                 _TX_WM_DESTROYWND                        =   0x7FF1;      // îêîí â ïîòîêå Canvas

//-----------------------------------------------------------------------------------------------------------------

int              _txInitialize();
void             _txCleanup();

HWND             _txCanvas_CreateWindow      (const SIZE* size);
inline bool      _txCanvas_OK() tx_nodiscard;

bool             _txCanvas_OnCREATE          (HWND wnd);
bool             _txCanvas_OnDESTROY         (HWND wnd);
bool             _txCanvas_OnCLOSE           (HWND);
bool             _txCanvas_OnPAINT           (HWND wnd);
bool             _txCanvas_OnKEYDOWN         (HWND wnd, WPARAM vk, LPARAM info);
bool             _txCanvas_OnCHAR            (HWND wnd, WPARAM ch, LPARAM info);
bool             _txCanvas_OnTIMER           (HWND wnd, WPARAM id);
bool             _txCanvas_OnMOUSEMOVE       (HWND wnd, WPARAM buttons, LPARAM coords);
bool             _txCanvas_OnMOUSELEAVE      (HWND wnd);
bool             _txCanvas_OnCREATEWND       (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnDESTROYWND      (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnCmdCONSOLE      (HWND wnd, WPARAM cmd);
bool             _txCanvas_OnCmdABOUT        (HWND wnd, WPARAM cmd);

unsigned WINAPI  _txCanvas_ThreadProc        (void* data);
LRESULT CALLBACK _txCanvas_WndProc           (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);

int              _txCanvas_SetRefreshLock    (int count);

HDC              _txBuffer_Create            (HWND wnd = NULL, const POINT* size = NULL, HBITMAP bitmap = NULL,
                                              RGBQUAD** pixels = NULL) tx_nodiscard;
bool             _txBuffer_Delete            (HDC* dc);
bool             _txBuffer_Select            (HGDIOBJ obj, HDC dc = txDC());

HWND             _txConsole_Attach();
bool             _txConsole_OK() tx_nodiscard;
bool             _txConsole_Detach           (bool activate);
bool             _txConsole_Draw             (HDC dc);
bool             _txConsole_SetUnicodeFont();

const char*       txRegisterClass            (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra);
HWND              txCreateExtraWindow        (CREATESTRUCT createData);
HICON            _txCreateTXIcon             (int size) tx_nodiscard;
int              _txSetFinishedText          (HWND wnd);
void             _txPauseBeforeTermination   (HWND canvas);
int              _txIsParentWaitable         (DWORD* parentPID = NULL) tx_nodiscard;
int              _txGetInput();

LRESULT CALLBACK _txPlayVideo_WndProc        (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
const char*      _txPlayVideo_FindVLC() tx_nodiscard;

bool             _txCreateShortcut           (const char shortcutName[],
                                              const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
                                              const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
                                              const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
                                              COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));

void*            _tx_DLGTEMPLATE_Create      (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                                              WORD controls, short x, short y, short cx, short cy,
                                              const char caption[], const char font[], WORD fontsize,
                                              const char menu[]) tx_nodiscard;

void*            _tx_DLGTEMPLATE_Add         (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                                              short x, short y, short cx, short cy,
                                              WORD id, const char wclass[], const char caption[]);

const char*      _txError                    (const char file[] = NULL, int line = 0, const char func[] = NULL, unsigned color = 0,
                                              const char msg[] = NULL, ...) tx_printfy (5);
const char*      _txProcessError             (const char file[], int line, const char func[], unsigned color,
                                              const char msg[], va_list args);
void             _txOnTerminate();
void             _txOnUnexpected();
void             _txOnPureCall();
void             _txOnNewHandlerAnsi();
int              _txOnNewHandler             (size_t size);
void             _txOnSignal                 (int signal = 0, int fpe = 0);
BOOL WINAPI      _txOnConsoleCtrlEvent       (DWORD type);
void             _txOnSecurityError          (int code, void*);
void             _txOnSecurityErrorAnsi      (const char* msg, void* ptr, int code);
int              _txOnMatherr                (_exception* except);
void             _txOnInvalidParam           (const wchar_t* expr, const wchar_t* func, const wchar_t* file,
                                              unsigned line, uintptr_t);
int              _txOnAllocHook              (int type, void* data, size_t size, int use, long request,
                                              const unsigned char* file, int line);
int              _txOnRTCFailure             (int type, const char* file, int line, const char* module, const char* format, ...) tx_printfy (5);
int              _txOnErrorReport            (int type, const char* text, int* ret);
int               tx_glGetError              (int setError = INT_MIN);

void             _txOnCExit();
void             _txOnExit                   (int      retcode);
void             _txOnFatalExit              (int      retcode);
void             _txOnExitProcess            (unsigned retcode);
void             _txOnFatalAppExitA          (unsigned action, const char message[]);
bool             _txOnTerminateProcess       (HANDLE process, unsigned retcode);
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
                 _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter);
void             _txWatchdogTerminator       (void* timeout);  // Only Arnold-type series are supported, not T1000

long WINAPI      _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc);
long WINAPI      _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc);
long             _txOnExceptionSEH           (EXCEPTION_POINTERS* exc, const char func[]);
intptr_t         _txDumpExceptionSEH         (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[]);
intptr_t         _txDumpExceptionObj         (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type);
intptr_t         _txDumpExceptionCPP         (char what[], intptr_t size, unsigned code = 0,
                                              unsigned params = 0, const ULONG_PTR info[] = NULL);

void             _txStackBackTrace           (const char file[] = "?", int line = 0, const char func[] = "?",
                                              bool readSource = true);
const char*      _txCaptureStackBackTrace    (int framesToSkip = 0, bool readSource = true,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
int              _txStackWalk                (int framesToSkip, size_t szCapture, void* capture[], unsigned long* backTraceHash,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
const char*      _txCaptureStackBackTraceTX  (int framesToSkip = 0, bool readSource = false);

const char*      _txSymPrintFromAddr         (void* addr = NULL, const char format[] = NULL, ...) tx_printfy (2);
bool             _txSymGetFromAddr           (void* addr, Win32::SYMBOL_INFO** symbol = NULL,
                                              Win32::IMAGEHLP_LINE64** line = NULL, const char** module = NULL,
                                              const char** source = NULL, int context = 2);
intptr_t         _txReadSource               (char buf[], intptr_t size, const char file[],
                                              int linStart = 0, int linEnd = INT_MIN, int linMark = INT_MIN);
bool             _txCreateMiniDump           (EXCEPTION_POINTERS* exc);

uintptr_t        _txSetProcAddress           (const char funcName[], uintptr_t newFunc, const char dllName[] = NULL,
                                              int useHotPatching = false, HMODULE module = NULL, bool debug = false);
bool             _txInDll() tx_nodiscard;
PROCESSENTRY32*  _txFindProcess              (unsigned pid = GetCurrentProcessId()) tx_nodiscard;
bool             _txKillProcess              (DWORD pid);
bool             _txIsBadReadPtr             (const void* address);
bool             _txCheckSourceCP            (int needCP = _TX_CODEPAGE, bool verbose = true);
bool             _txGetCommandLine           (wchar_t cmdLine[], size_t szCmdLine, unsigned pid = _getpid());
IMAGE_NT_HEADERS*_txGetNtHeaders             (HMODULE module = GetModuleHandle (NULL)) tx_nodiscard;
const char*      _txAppInfo() tx_nodiscard;

intptr_t         _tx_snprintf_s              (char stream[], intptr_t size, const char format[], ...) tx_printfy (3);
intptr_t         _tx_vsnprintf_s             (char stream[], intptr_t size, const char format[], va_list arg);
void              txReopenStdio();

#if defined (_CLANG_VER) && !defined (_MSC_VER)
void             _txLibCppDebugFunction      (std::__libcpp_debug_info const& info);
#endif

#if defined (__CYGWIN__)

int              _getch();
int              _putch (int ch);
int              _kbhit() tx_nodiscard;

#endif

//-----------------------------------------------------------------------------------------------------------------
// There are macros for __FILE__ and __LINE__ to work properly.

#if !defined (NDEBUG)

    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) && \
                                                     (assert (cond), true) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå."), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("Ïàðàìåòð \"%s\" íåâåðåí. Âîçìîæíî, ýòîò õîëñò íå ñîçäàí, " \
                                                                "èëè óæå óíè÷òîæåí, èëè íå çàãðóçèëàñü êàðòèíêà.", #dc), 1) )
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( (!(dc) &&                                           \
                                                     _TX_TXWINDOW_FAILED()) || _TX_HDC_FAILED (dc) )

#else
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) )

    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )

    #define _TX_DEFAULT_HDC_FAILED(dc)         ( !(dc) &&                                            \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
#endif

//-----------------------------------------------------------------------------------------------------------------
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but MSVC rejects it. So sad. :'(

#if !defined (NDEBUG)
    #define  _TX_ON_DEBUG( code )              { code; }
#else
    #define  _TX_ON_DEBUG( code )              ;
#endif

//-----------------------------------------------------------------------------------------------------------------
// Invokes an error without location information. "$$" restores TX-related call location context

#define _TX_UNEXPECTED( ... )                  $$ _txError (NULL, 0, NULL, 0, ##__VA_ARGS__)

//-----------------------------------------------------------------------------------------------------------------
// Safe call of a function via its pointer

#define _TX_CALL(  func, param )               ( (func)? ((func) param) :       0 )
#define _TX_CALLv( func, param )               ( (func)? ((func) param) : (void)0 )

//-----------------------------------------------------------------------------------------------------------------
// This is a macro because cond is an expression and is not always a function. Lack of lambdas in pre-C++0x.

#define      _txWaitFor( cond, time )          { for (DWORD _t = GetTickCount() + (time); \
                                                      !(cond) && GetTickCount() < _t;     \
                                                      Sleep (_txWindowUpdateInterval)) ;  \
                                                 if  (!(cond))                            \
                                                      _txTrace (__FILE__, __LINE__, NULL, "WARNING: Timeout: " #cond "."); }
//-----------------------------------------------------------------------------------------------------------------
// Detouring in case of SEH mechanism

#define _txSetJmp()                            ( setjmp (_txDumpExceptionObjJmp) == 0 )

#define _txClearJmp()                          { *(unsigned long long*) _txDumpExceptionObjJmp = 0; }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal global data
//! @name    Âíóòðåííèå ãëîáàëüíûå äàííûå
//
//           Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
//           Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåð, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
//           Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
//           Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé, èëè êëàññ.
//=================================================================================================================
//! @{

int                          _txInitialized              = _TX_NOINIT || _txInitialize();

volatile const unsigned      _txCanaryFirst              = 0x776F656D; // A very system value

volatile unsigned            _txMainThreadId             = 0;          // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
volatile HANDLE              _txMainThread               = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà

volatile unsigned            _txCanvas_ThreadId          = 0;          // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
volatile HANDLE              _txCanvas_Thread            = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
volatile HWND                _txCanvas_Window            = NULL;       // Äåñêðèïòîð îêíà õîëñòà TXLib

HDC                          _txCanvas_BackBuf[2]        = {NULL,      // [0] Main TXLib in-memory DC, where user's pictures lies
                                                            NULL};     // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()

RGBQUAD*                     _txCanvas_Pixels            = NULL;       // Memory buffer of _txCanvas_BackBuf[0]

HBITMAP                      _txStockBitmap              = NULL;       // Equivalent of GetStockObject (BITMAP),
                                                                       // see https://devblogs.microsoft.com/oldnewthing/20100416-00/?p=14313

CRITICAL_SECTION             _txCanvas_LockBackBuf       = {0,-1};     // Prevent simultaneous access to back buffer, see txLock()

UINT_PTR                     _txCanvas_RefreshTimer      = 1;          // Timer ID to redraw TXLib window
volatile int                 _txCanvas_RefreshLock       = 0;          // Blocks auto on-timer canvas update, see txBegin/txEnd

::std::vector<HDC>*          _txCanvas_UserDCs           = NULL;       // List of DCs allocated, for auto-free

volatile bool                _txConsole_IsBlinking       = true;       // To blink or not to blink, that is the question.

bool                         _txConsole                  = false;      // Only first TXLib module in app can own the console
bool                         _txMain                     = false;      // First TXLib wnd opened (closing it terminates program)
bool                         _txIsDll                    = false;      // TXLib module is in DLL
volatile bool                _txRunning                  = false;      // main() is still running
volatile bool                _txExit                     = false;      // exit() is active

volatile POINT               _txMousePos                 = {-1,-1};    // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
volatile unsigned            _txMouseButtons             = 0;

volatile WNDPROC             _txAltWndProc               = NULL;       // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().

_tx_thread _txLoc            _txLoc::Cur                 = {};         // Execution point tracking and trace state, see "$" macro

volatile int                 _txErrors                   = 0;          // TX_ERROR calls sequental number
int                          _txOGLError                 = 0;          // Last OpenGL error when using tx_glGetError()
volatile long                _txSENumber                 = 0;          // SEH exceptions sequental number
volatile long                _txSEFatalNumber            = 0;          // SEH fatal exceptions sequental number
char                         _txDumpSE [_TX_BUFSIZE]     = "";         // SEH dump data area
char                         _txTraceSE[_TX_HUGEBUFSIZE] = "";         // Stack trace data area

LPTOP_LEVEL_EXCEPTION_FILTER _txPrevUEFilter             = NULL;       // Previous UnhandledExceptionFilter

jmp_buf                      _txDumpExceptionObjJmp      = {};         // Hook for _txDumpExceptionObj

const volatile uintptr_t     _txForceImport[]            = { (uintptr_t) ::TerminateProcess,              (uintptr_t) ::ExitProcess,
                                                             (uintptr_t) ::FatalExit,                     (uintptr_t) ::FatalAppExitA,
                                                             (uintptr_t) ::exit,                          (uintptr_t) Win32::_controlfp,
                                                             (uintptr_t) Win32::Polyline,                 (uintptr_t) Win32::PolyBezier,
                                                             (uintptr_t) Win32::RoundRect,                (uintptr_t) Win32::RemoveVectoredExceptionHandler,
                                                             (uintptr_t) Win32::PlgBlt,                   (uintptr_t) Win32::RtlCaptureStackBackTrace,
                                                             (uintptr_t) Win32::SymInitialize,            (uintptr_t) Win32::MinGW::SymInitialize,
                                                             (uintptr_t) Win32::SymSetOptions,            (uintptr_t) Win32::MinGW::SymSetOptions,
                                                             (uintptr_t) Win32::SymGetLineFromAddr64,     (uintptr_t) Win32::MinGW::SymGetLineFromAddr64,
                                                             (uintptr_t) Win32::SymFromAddr,              (uintptr_t) Win32::MinGW::SymFromAddr,
                                                             (uintptr_t) Win32::SymCleanup,               (uintptr_t) Win32::MinGW::SymCleanup,
                                                             (uintptr_t) Win32::SymGetModuleBase64,       (uintptr_t) Win32::MinGW::SymGetModuleBase64,
                                                             (uintptr_t) Win32::SymFunctionTableAccess64, (uintptr_t) Win32::MinGW::SymFunctionTableAccess64,
                                                             (uintptr_t) Win32::StackWalk64,              (uintptr_t) Win32::MinGW::StackWalk64,
                                                             (uintptr_t) Win32::StrStrIA,                 (uintptr_t) Win32::Wow64GetThreadContext };

volatile const unsigned      _txCanaryLast               = 0x5E2E2E5E; // Another very system value

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib engine init/check/cleanup
//! @name    Èíèöèàëèçàöèÿ/ïðîâåðêà/çàâåðøåíèå TXLib
//=================================================================================================================
//! @{

//-----------------------------------------------------------------------------------------------------------------
//{          Early initialization
//-----------------------------------------------------------------------------------------------------------------

int _txInitialize()
    {
    if (_txInitialized) return 1;
    _txInitialized = 1;

    #if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)  // See http://msdn.microsoft.com/en-us/library/w2fhc9a3%28v=vs.90%29.aspx
    _CrtSetBreakAlloc (_TX_ALLOC_BREAK);                 // and http://support.microsoft.com/ru-ru/kb/151585
    #endif

    #if defined (_TX_ALLOW_TRACE)
    _txLocLvlSet (1);
    #endif

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
                                     "compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

    _txMainThreadId = GetCurrentThreadId();
    _txMainThread   = OpenThread (THREAD_ALL_ACCESS, false, _txMainThreadId);

$3  _txIsDll = _txInDll();

$   if (!_txIsDll)
        {
$       _txConsole = ! FindAtom ("_txConsole");
$       (void)          AddAtom ("_txConsole");
        }

$   if (_txConsole)
        {
$       _txCheckSourceCP (_TX_CODEPAGE, true);

$       unsigned long stackSize = _TX_STACKSIZE;
$       _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$       _txOnSignal();

$       if (!*_txLogName)
            {$ _tx_snprintf_s (_txLogName, sizeof (_txLogName) - 1, "%s.log", txGetModuleFileName()); }

$       if (!_txIsDll)
            {
$           _TX_CALL  (Win32::AddVectoredExceptionHandler, (1, (PVECTORED_EXCEPTION_HANDLER)  _txVectoredExceptionHandler));
$           _txPrevUEFilter = SetUnhandledExceptionFilter  (   (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter);
            }

$       ::std::set_terminate             (_txOnTerminate);
$       ::std::set_new_handler           (_txOnNewHandlerAnsi);
$       _TX_CALL (Win32::set_unexpected, (_txOnUnexpected));

        #if defined (_CLANG_VER) && !defined (_MSC_VER)
$       ::std::__libcpp_debug_function = _txLibCppDebugFunction;
        #endif

$       SetConsoleCtrlHandler (_txOnConsoleCtrlEvent, true);

$       SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);

        #if defined (_MSC_VER)

$       _set_printf_count_output (1);

$       _set_new_handler (_txOnNewHandler);
$       _set_new_mode (1);

        #if !defined (_CLANG_VER)

$       _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$       _CrtSetAllocHook (_txOnAllocHook);

$       unsigned mode = _CRTDBG_MODE_FILE;
$       if (_CrtSetReportHook2 (_CRT_RPTHOOK_INSTALL, (_CRT_REPORT_HOOK) _txOnErrorReport) > 0) mode = 0;

$       _CrtSetReportMode (_CRT_WARN,   _CRTDBG_MODE_DEBUG | mode);
$       _CrtSetReportMode (_CRT_ERROR,  _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportFile (_CRT_WARN,   _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ERROR,  _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);

        #endif

$       _set_abort_behavior (_WRITE_ABORT_MSG, _WRITE_ABORT_MSG);
$       _set_abort_behavior (0,                _CALL_REPORTFAULT);

$       _RTC_SetErrorFunc              (_txOnRTCFailure);
$       _set_purecall_handler          (_txOnPureCall);
$       _set_invalid_parameter_handler (_txOnInvalidParam);

        #endif

        #if defined (__STDC_LIB_EXT1__)
$       ::std::set_constraint_handler_s (_txOnSecurityErrorAnsi);
        #endif

        #if !defined (__CYGWIN__) && defined (_GCC_VER) && (_GCC_VER >= 530) && !defined (i386)
$       __setusermatherr (_txOnMatherr);
        #endif

        #if !defined (__CYGWIN__)
$       _set_error_mode (_OUT_TO_MSGBOX | _OUT_TO_STDERR);
        #endif

$       HWND console = _txConsole_Attach();
$       SetWindowTextA (console, txGetModuleFileName (false));
        }

$   InitializeCriticalSection (&_txCanvas_LockBackBuf);

$   _txSetProcAddress ("ExitProcess",                 (uintptr_t) _txOnExitProcess,                 "KERNEL32.DLL");
$   _txSetProcAddress ("TerminateProcess",            (uintptr_t) _txOnTerminateProcess,            "KERNEL32.DLL");
$   _txSetProcAddress ("FatalExit",                   (uintptr_t) _txOnFatalExit,                   "KERNEL32.DLL");
$   _txSetProcAddress ("FatalAppExitA",               (uintptr_t) _txOnFatalAppExitA,               "KERNEL32.DLL");
$   _txSetProcAddress ("UnhandledExceptionFilter",    (uintptr_t) _txUnhandledExceptionFilter,      "KERNEL32.DLL", true);
$   _txSetProcAddress ("SetUnhandledExceptionFilter", (uintptr_t) _txOnSetUnhandledExceptionFilter, "KERNEL32.DLL");
$   _txSetProcAddress ("exit",                        (uintptr_t) _txOnExit);
$   _txSetProcAddress ("_cexit",                      (uintptr_t) _txOnCExit);

$   atexit (_txCleanup);

$   if (_txConsole)
        {
$       txSetConsoleAttr (FOREGROUND_LIGHTGRAY);

$       tx_fpreset();

$       srand ((unsigned) time (NULL));

$       SetLastError (0);
$       errno = 0;

        #if !defined (__CYGWIN__)
$       _doserrno = 0;
        #endif
        }

$   HDC dc = Win32::CreateCompatibleDC (NULL); dc asserted;
$   _txStockBitmap = (HBITMAP) Win32::SelectObject (dc, Win32::CreateCompatibleBitmap (dc, 1, 1)); _txStockBitmap asserted;
$   Win32::DeleteObject (Win32::SelectObject (dc, _txStockBitmap)) asserted;
$   Win32::DeleteDC (dc) asserted;

$   return 1;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCheckSourceCP (int needCP /*= _TX_CODEPAGE*/, bool verbose /*= true*/)
    {
$3  const char* sCodePage = NULL;
$   int codePage = 0;

$   switch (((unsigned const char*) "À") [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }

$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please

$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }

$   return (codePage == needCP);
    }

//-----------------------------------------------------------------------------------------------------------------

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;

    static char dllPaths [2][MAX_PATH] = {"", ""};

    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";

        // dllPaths[0] is relative to the TX Setup directory stored in the Registry

        char* path = dllPaths[0];

        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);

        // dllPaths[1] is relative to TXib.h file used in compilation

        path = dllPaths[1];

        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }

        if (char* dir = strrchr (path, '\\')) *dir = 0;

        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }

    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);

    if (arch)
        {
        assert (arch >= dllFileName);

        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));

        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }

    HMODULE   dll = GetModuleHandle (dllFileName);

    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);

    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);

        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);

        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }

    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);

    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;

    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);

    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè
#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
//=================================================================================================================
 
const int        _TX_IDM_ABOUT                            =   40000,       // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
                 _TX_IDM_CONSOLE                          =   40001,
                 _TX_WM_CREATEWND                         =   0x7FF0,      // Ñîîáùåíèÿ äëÿ ñîçäàíèÿ/óíè÷òîæåíèÿ
                 _TX_WM_DESTROYWND                        =   0x7FF1;      // îêîí â ïîòîêå Canvas
 
//-----------------------------------------------------------------------------------------------------------------
 
int              _txInitialize();
void             _txCleanup();
 
HWND             _txCanvas_CreateWindow      (const SIZE* size);
inline bool      _txCanvas_OK() tx_nodiscard;
 
bool             _txCanvas_OnCREATE          (HWND wnd);
bool             _txCanvas_OnDESTROY         (HWND wnd);
bool             _txCanvas_OnCLOSE           (HWND);
bool             _txCanvas_OnPAINT           (HWND wnd);
bool             _txCanvas_OnKEYDOWN         (HWND wnd, WPARAM vk, LPARAM info);
bool             _txCanvas_OnCHAR            (HWND wnd, WPARAM ch, LPARAM info);
bool             _txCanvas_OnTIMER           (HWND wnd, WPARAM id);
bool             _txCanvas_OnMOUSEMOVE       (HWND wnd, WPARAM buttons, LPARAM coords);
bool             _txCanvas_OnMOUSELEAVE      (HWND wnd);
bool             _txCanvas_OnCREATEWND       (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnDESTROYWND      (HWND wnd, WPARAM, LPARAM lpar);
bool             _txCanvas_OnCmdCONSOLE      (HWND wnd, WPARAM cmd);
bool             _txCanvas_OnCmdABOUT        (HWND wnd, WPARAM cmd);
 
unsigned WINAPI  _txCanvas_ThreadProc        (void* data);
LRESULT CALLBACK _txCanvas_WndProc           (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
 
int              _txCanvas_SetRefreshLock    (int count);
 
HDC              _txBuffer_Create            (HWND wnd = NULL, const POINT* size = NULL, HBITMAP bitmap = NULL,
                                              RGBQUAD** pixels = NULL) tx_nodiscard;
bool             _txBuffer_Delete            (HDC* dc);
bool             _txBuffer_Select            (HGDIOBJ obj, HDC dc = txDC());
 
HWND             _txConsole_Attach();
bool             _txConsole_OK() tx_nodiscard;
bool             _txConsole_Detach           (bool activate);
bool             _txConsole_Draw             (HDC dc);
bool             _txConsole_SetUnicodeFont();
 
const char*       txRegisterClass            (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra);
HWND              txCreateExtraWindow        (CREATESTRUCT createData);
HICON            _txCreateTXIcon             (int size) tx_nodiscard;
int              _txSetFinishedText          (HWND wnd);
void             _txPauseBeforeTermination   (HWND canvas);
int              _txIsParentWaitable         (DWORD* parentPID = NULL) tx_nodiscard;
int              _txGetInput();
 
LRESULT CALLBACK _txPlayVideo_WndProc        (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
const char*      _txPlayVideo_FindVLC() tx_nodiscard;
 
bool             _txCreateShortcut           (const char shortcutName[],
                                              const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
                                              const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
                                              const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
                                              COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));
 
void*            _tx_DLGTEMPLATE_Create      (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                                              WORD controls, short x, short y, short cx, short cy,
                                              const char caption[], const char font[], WORD fontsize,
                                              const char menu[]) tx_nodiscard;
 
void*            _tx_DLGTEMPLATE_Add         (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                                              short x, short y, short cx, short cy,
                                              WORD id, const char wclass[], const char caption[]);
 
const char*      _txError                    (const char file[] = NULL, int line = 0, const char func[] = NULL, unsigned color = 0,
                                              const char msg[] = NULL, ...) tx_printfy (5);
const char*      _txProcessError             (const char file[], int line, const char func[], unsigned color,
                                              const char msg[], va_list args);
void             _txOnTerminate();
void             _txOnUnexpected();
void             _txOnPureCall();
void             _txOnNewHandlerAnsi();
int              _txOnNewHandler             (size_t size);
void             _txOnSignal                 (int signal = 0, int fpe = 0);
BOOL WINAPI      _txOnConsoleCtrlEvent       (DWORD type);
void             _txOnSecurityError          (int code, void*);
void             _txOnSecurityErrorAnsi      (const char* msg, void* ptr, int code);
int              _txOnMatherr                (_exception* except);
void             _txOnInvalidParam           (const wchar_t* expr, const wchar_t* func, const wchar_t* file,
                                              unsigned line, uintptr_t);
int              _txOnAllocHook              (int type, void* data, size_t size, int use, long request,
                                              const unsigned char* file, int line);
int              _txOnRTCFailure             (int type, const char* file, int line, const char* module, const char* format, ...) tx_printfy (5);
int              _txOnErrorReport            (int type, const char* text, int* ret);
int               tx_glGetError              (int setError = INT_MIN);
 
void             _txOnCExit();
void             _txOnExit                   (int      retcode);
void             _txOnFatalExit              (int      retcode);
void             _txOnExitProcess            (unsigned retcode);
void             _txOnFatalAppExitA          (unsigned action, const char message[]);
bool             _txOnTerminateProcess       (HANDLE process, unsigned retcode);
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
                 _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter);
void             _txWatchdogTerminator       (void* timeout);  // Only Arnold-type series are supported, not T1000
 
long WINAPI      _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc);
long WINAPI      _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc);
long             _txOnExceptionSEH           (EXCEPTION_POINTERS* exc, const char func[]);
intptr_t         _txDumpExceptionSEH         (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[]);
intptr_t         _txDumpExceptionObj         (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type);
intptr_t         _txDumpExceptionCPP         (char what[], intptr_t size, unsigned code = 0,
                                              unsigned params = 0, const ULONG_PTR info[] = NULL);
 
void             _txStackBackTrace           (const char file[] = "?", int line = 0, const char func[] = "?",
                                              bool readSource = true);
const char*      _txCaptureStackBackTrace    (int framesToSkip = 0, bool readSource = true,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
int              _txStackWalk                (int framesToSkip, size_t szCapture, void* capture[], unsigned long* backTraceHash,
                                              CONTEXT* context = NULL, HANDLE thread = GetCurrentThread());
const char*      _txCaptureStackBackTraceTX  (int framesToSkip = 0, bool readSource = false);
 
const char*      _txSymPrintFromAddr         (void* addr = NULL, const char format[] = NULL, ...) tx_printfy (2);
bool             _txSymGetFromAddr           (void* addr, Win32::SYMBOL_INFO** symbol = NULL,
                                              Win32::IMAGEHLP_LINE64** line = NULL, const char** module = NULL,
                                              const char** source = NULL, int context = 2);
intptr_t         _txReadSource               (char buf[], intptr_t size, const char file[],
                                              int linStart = 0, int linEnd = INT_MIN, int linMark = INT_MIN);
bool             _txCreateMiniDump           (EXCEPTION_POINTERS* exc);
 
uintptr_t        _txSetProcAddress           (const char funcName[], uintptr_t newFunc, const char dllName[] = NULL,
                                              int useHotPatching = false, HMODULE module = NULL, bool debug = false);
bool             _txInDll() tx_nodiscard;
PROCESSENTRY32*  _txFindProcess              (unsigned pid = GetCurrentProcessId()) tx_nodiscard;
bool             _txKillProcess              (DWORD pid);
bool             _txIsBadReadPtr             (const void* address);
bool             _txCheckSourceCP            (int needCP = _TX_CODEPAGE, bool verbose = true);
bool             _txGetCommandLine           (wchar_t cmdLine[], size_t szCmdLine, unsigned pid = _getpid());
IMAGE_NT_HEADERS*_txGetNtHeaders             (HMODULE module = GetModuleHandle (NULL)) tx_nodiscard;
const char*      _txAppInfo() tx_nodiscard;
 
intptr_t         _tx_snprintf_s              (char stream[], intptr_t size, const char format[], ...) tx_printfy (3);
intptr_t         _tx_vsnprintf_s             (char stream[], intptr_t size, const char format[], va_list arg);
void              txReopenStdio();
 
#if defined (_CLANG_VER) && !defined (_MSC_VER)
void             _txLibCppDebugFunction      (std::__libcpp_debug_info const& info);
#endif
 
#if defined (__CYGWIN__)
 
int              _getch();
int              _putch (int ch);
int              _kbhit() tx_nodiscard;
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
// There are macros for __FILE__ and __LINE__ to work properly.
 
#if !defined (NDEBUG)
 
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) && \
                                                     (assert (cond), true) )
 
    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå."), 1) )
 
    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) && \
                                                     (TX_ERROR ("Ïàðàìåòð \"%s\" íåâåðåí. Âîçìîæíî, ýòîò õîëñò íå ñîçäàí, " \
                                                                "èëè óæå óíè÷òîæåí, èëè íå çàãðóçèëàñü êàðòèíêà.", #dc), 1) )
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( (!(dc) &&                                           \
                                                     _TX_TXWINDOW_FAILED()) || _TX_HDC_FAILED (dc) )
 
#else
    #define  _TX_ARGUMENT_FAILED( cond )       ( !(cond) &&                                          \
                                                     (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1) )
 
    #define  _TX_TXWINDOW_FAILED()             ( !txOK() &&                                          \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
 
    #define  _TX_HDC_FAILED( dc )              ( !Win32::GetObjectType (dc) &&                       \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
 
    #define _TX_DEFAULT_HDC_FAILED(dc)         ( !(dc) &&                                            \
                                                     (SetLastErrorEx (ERROR_INVALID_DATA,  0), 1) )
#endif
 
//-----------------------------------------------------------------------------------------------------------------
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but MSVC rejects it. So sad. :'(
 
#if !defined (NDEBUG)
    #define  _TX_ON_DEBUG( code )              { code; }
#else
    #define  _TX_ON_DEBUG( code )              ;
#endif
 
//-----------------------------------------------------------------------------------------------------------------
// Invokes an error without location information. "$$" restores TX-related call location context
 
#define _TX_UNEXPECTED( ... )                  $$ _txError (NULL, 0, NULL, 0, ##__VA_ARGS__)
 
//-----------------------------------------------------------------------------------------------------------------
// Safe call of a function via its pointer
 
#define _TX_CALL(  func, param )               ( (func)? ((func) param) :       0 )
#define _TX_CALLv( func, param )               ( (func)? ((func) param) : (void)0 )
 
//-----------------------------------------------------------------------------------------------------------------
// This is a macro because cond is an expression and is not always a function. Lack of lambdas in pre-C++0x.
 
#define      _txWaitFor( cond, time )          { for (DWORD _t = GetTickCount() + (time); \
                                                      !(cond) && GetTickCount() < _t;     \
                                                      Sleep (_txWindowUpdateInterval)) ;  \
                                                 if  (!(cond))                            \
                                                      _txTrace (__FILE__, __LINE__, NULL, "WARNING: Timeout: " #cond "."); }
//-----------------------------------------------------------------------------------------------------------------
// Detouring in case of SEH mechanism
 
#define _txSetJmp()                            ( setjmp (_txDumpExceptionObjJmp) == 0 )
 
#define _txClearJmp()                          { *(unsigned long long*) _txDumpExceptionObjJmp = 0; }
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Internal global data
//
//           Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
//           Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåð, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
//           Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
//           Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé, èëè êëàññ.
//=================================================================================================================
 
int                          _txInitialized              = _TX_NOINIT || _txInitialize();
 
volatile const unsigned      _txCanaryFirst              = 0x776F656D; // A very system value
 
volatile unsigned            _txMainThreadId             = 0;          // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
volatile HANDLE              _txMainThread               = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
 
volatile unsigned            _txCanvas_ThreadId          = 0;          // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
volatile HANDLE              _txCanvas_Thread            = NULL;       // Äåêñðèïòîð ýòîãî ïîòîêà
volatile HWND                _txCanvas_Window            = NULL;       // Äåñêðèïòîð îêíà õîëñòà TXLib
 
HDC                          _txCanvas_BackBuf[2]        = {NULL,      // [0] Main TXLib in-memory DC, where user's pictures lies
                                                            NULL};     // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()
 
RGBQUAD*                     _txCanvas_Pixels            = NULL;       // Memory buffer of _txCanvas_BackBuf[0]
 
HBITMAP                      _txStockBitmap              = NULL;       // Equivalent of GetStockObject (BITMAP),
                                                                       // see https://devblogs.microsoft.com/oldnewthing/20100416-00/?p=14313
 
CRITICAL_SECTION             _txCanvas_LockBackBuf       = {0,-1};     // Prevent simultaneous access to back buffer, see txLock()
 
UINT_PTR                     _txCanvas_RefreshTimer      = 1;          // Timer ID to redraw TXLib window
volatile int                 _txCanvas_RefreshLock       = 0;          // Blocks auto on-timer canvas update, see txBegin/txEnd
 
::std::vector<HDC>*          _txCanvas_UserDCs           = NULL;       // List of DCs allocated, for auto-free
 
volatile bool                _txConsole_IsBlinking       = true;       // To blink or not to blink, that is the question.
 
bool                         _txConsole                  = false;      // Only first TXLib module in app can own the console
bool                         _txMain                     = false;      // First TXLib wnd opened (closing it terminates program)
bool                         _txIsDll                    = false;      // TXLib module is in DLL
volatile bool                _txRunning                  = false;      // main() is still running
volatile bool                _txExit                     = false;      // exit() is active
 
volatile POINT               _txMousePos                 = {-1,-1};    // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
volatile unsigned            _txMouseButtons             = 0;
 
volatile WNDPROC             _txAltWndProc               = NULL;       // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().
 
_tx_thread _txLoc            _txLoc::Cur                 = {};         // Execution point tracking and trace state, see "$" macro
 
volatile int                 _txErrors                   = 0;          // TX_ERROR calls sequental number
int                          _txOGLError                 = 0;          // Last OpenGL error when using tx_glGetError()
volatile long                _txSENumber                 = 0;          // SEH exceptions sequental number
volatile long                _txSEFatalNumber            = 0;          // SEH fatal exceptions sequental number
char                         _txDumpSE [_TX_BUFSIZE]     = "";         // SEH dump data area
char                         _txTraceSE[_TX_HUGEBUFSIZE] = "";         // Stack trace data area
 
LPTOP_LEVEL_EXCEPTION_FILTER _txPrevUEFilter             = NULL;       // Previous UnhandledExceptionFilter
 
jmp_buf                      _txDumpExceptionObjJmp      = {};         // Hook for _txDumpExceptionObj
 
const volatile uintptr_t     _txForceImport[]            = { (uintptr_t) ::TerminateProcess,              (uintptr_t) ::ExitProcess,
                                                             (uintptr_t) ::FatalExit,                     (uintptr_t) ::FatalAppExitA,
                                                             (uintptr_t) ::exit,                          (uintptr_t) Win32::_controlfp,
                                                             (uintptr_t) Win32::Polyline,                 (uintptr_t) Win32::PolyBezier,
                                                             (uintptr_t) Win32::RoundRect,                (uintptr_t) Win32::RemoveVectoredExceptionHandler,
                                                             (uintptr_t) Win32::PlgBlt,                   (uintptr_t) Win32::RtlCaptureStackBackTrace,
                                                             (uintptr_t) Win32::SymInitialize,            (uintptr_t) Win32::MinGW::SymInitialize,
                                                             (uintptr_t) Win32::SymSetOptions,            (uintptr_t) Win32::MinGW::SymSetOptions,
                                                             (uintptr_t) Win32::SymGetLineFromAddr64,     (uintptr_t) Win32::MinGW::SymGetLineFromAddr64,
                                                             (uintptr_t) Win32::SymFromAddr,              (uintptr_t) Win32::MinGW::SymFromAddr,
                                                             (uintptr_t) Win32::SymCleanup,               (uintptr_t) Win32::MinGW::SymCleanup,
                                                             (uintptr_t) Win32::SymGetModuleBase64,       (uintptr_t) Win32::MinGW::SymGetModuleBase64,
                                                             (uintptr_t) Win32::SymFunctionTableAccess64, (uintptr_t) Win32::MinGW::SymFunctionTableAccess64,
                                                             (uintptr_t) Win32::StackWalk64,              (uintptr_t) Win32::MinGW::StackWalk64,
                                                             (uintptr_t) Win32::StrStrIA,                 (uintptr_t) Win32::Wow64GetThreadContext };
 
volatile const unsigned      _txCanaryLast               = 0x5E2E2E5E; // Another very system value
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          TXLib engine init/check/cleanup
//=================================================================================================================
 
//-----------------------------------------------------------------------------------------------------------------
//{          Early initialization
//-----------------------------------------------------------------------------------------------------------------
 
int _txInitialize()
    {
    if (_txInitialized) return 1;
    _txInitialized = 1;
 
    #if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)  // See http://msdn.microsoft.com/en-us/library/w2fhc9a3%28v=vs.90%29.aspx
    _CrtSetBreakAlloc (_TX_ALLOC_BREAK);                 // and http://support.microsoft.com/ru-ru/kb/151585
    #endif
 
    #if defined (_TX_ALLOW_TRACE)
    _txLocLvlSet (1);
    #endif
 
    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
                                     "compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));
 
    _txMainThreadId = GetCurrentThreadId();
    _txMainThread   = OpenThread (THREAD_ALL_ACCESS, false, _txMainThreadId);
 
$3  _txIsDll = _txInDll();
 
$   if (!_txIsDll)
        {
$       _txConsole = ! FindAtom ("_txConsole");
$       (void)          AddAtom ("_txConsole");
        }
 
$   if (_txConsole)
        {
$       _txCheckSourceCP (_TX_CODEPAGE, true);
 
$       unsigned long stackSize = _TX_STACKSIZE;
$       _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));
 
$       _txOnSignal();
 
$       if (!*_txLogName)
            {$ _tx_snprintf_s (_txLogName, sizeof (_txLogName) - 1, "%s.log", txGetModuleFileName()); }
 
$       if (!_txIsDll)
            {
$           _TX_CALL  (Win32::AddVectoredExceptionHandler, (1, (PVECTORED_EXCEPTION_HANDLER)  _txVectoredExceptionHandler));
$           _txPrevUEFilter = SetUnhandledExceptionFilter  (   (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter);
            }
 
$       ::std::set_terminate             (_txOnTerminate);
$       ::std::set_new_handler           (_txOnNewHandlerAnsi);
$       _TX_CALL (Win32::set_unexpected, (_txOnUnexpected));
 
        #if defined (_CLANG_VER) && !defined (_MSC_VER)
$       ::std::__libcpp_debug_function = _txLibCppDebugFunction;
        #endif
 
$       SetConsoleCtrlHandler (_txOnConsoleCtrlEvent, true);
 
$       SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
 
        #if defined (_MSC_VER)
 
$       _set_printf_count_output (1);
 
$       _set_new_handler (_txOnNewHandler);
$       _set_new_mode (1);
 
        #if !defined (_CLANG_VER)
 
$       _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$       _CrtSetAllocHook (_txOnAllocHook);
 
$       unsigned mode = _CRTDBG_MODE_FILE;
$       if (_CrtSetReportHook2 (_CRT_RPTHOOK_INSTALL, (_CRT_REPORT_HOOK) _txOnErrorReport) > 0) mode = 0;
 
$       _CrtSetReportMode (_CRT_WARN,   _CRTDBG_MODE_DEBUG | mode);
$       _CrtSetReportMode (_CRT_ERROR,  _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_DEBUG | mode | _CRTDBG_MODE_WNDW);
$       _CrtSetReportFile (_CRT_WARN,   _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ERROR,  _CRTDBG_FILE_STDERR);
$       _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);
 
        #endif
 
$       _set_abort_behavior (_WRITE_ABORT_MSG, _WRITE_ABORT_MSG);
$       _set_abort_behavior (0,                _CALL_REPORTFAULT);
 
$       _RTC_SetErrorFunc              (_txOnRTCFailure);
$       _set_purecall_handler          (_txOnPureCall);
$       _set_invalid_parameter_handler (_txOnInvalidParam);
 
        #endif
 
        #if defined (__STDC_LIB_EXT1__)
$       ::std::set_constraint_handler_s (_txOnSecurityErrorAnsi);
        #endif
 
        #if !defined (__CYGWIN__) && defined (_GCC_VER) && (_GCC_VER >= 530) && !defined (i386)
$       __setusermatherr (_txOnMatherr);
        #endif
 
        #if !defined (__CYGWIN__)
$       _set_error_mode (_OUT_TO_MSGBOX | _OUT_TO_STDERR);
        #endif
 
$       HWND console = _txConsole_Attach();
$       SetWindowTextA (console, txGetModuleFileName (false));
        }
 
$   InitializeCriticalSection (&_txCanvas_LockBackBuf);
 
$   _txSetProcAddress ("ExitProcess",                 (uintptr_t) _txOnExitProcess,                 "KERNEL32.DLL");
$   _txSetProcAddress ("TerminateProcess",            (uintptr_t) _txOnTerminateProcess,            "KERNEL32.DLL");
$   _txSetProcAddress ("FatalExit",                   (uintptr_t) _txOnFatalExit,                   "KERNEL32.DLL");
$   _txSetProcAddress ("FatalAppExitA",               (uintptr_t) _txOnFatalAppExitA,               "KERNEL32.DLL");
$   _txSetProcAddress ("UnhandledExceptionFilter",    (uintptr_t) _txUnhandledExceptionFilter,      "KERNEL32.DLL", true);
$   _txSetProcAddress ("SetUnhandledExceptionFilter", (uintptr_t) _txOnSetUnhandledExceptionFilter, "KERNEL32.DLL");
$   _txSetProcAddress ("exit",                        (uintptr_t) _txOnExit);
$   _txSetProcAddress ("_cexit",                      (uintptr_t) _txOnCExit);
 
$   atexit (_txCleanup);
 
$   if (_txConsole)
        {
$       txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
 
$       tx_fpreset();
 
$       srand ((unsigned) time (NULL));
 
$       SetLastError (0);
$       errno = 0;
 
        #if !defined (__CYGWIN__)
$       _doserrno = 0;
        #endif
        }
 
$   HDC dc = Win32::CreateCompatibleDC (NULL); dc asserted;
$   _txStockBitmap = (HBITMAP) Win32::SelectObject (dc, Win32::CreateCompatibleBitmap (dc, 1, 1)); _txStockBitmap asserted;
$   Win32::DeleteObject (Win32::SelectObject (dc, _txStockBitmap)) asserted;
$   Win32::DeleteDC (dc) asserted;
 
$   return 1;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCheckSourceCP (int needCP /*= _TX_CODEPAGE*/, bool verbose /*= true*/)
    {
$3  const char* sCodePage = NULL;
$   int codePage = 0;
 
$   switch (((unsigned const char*) "À) [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }

$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please

$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }

$   return (codePage == needCP);
    }

//-----------------------------------------------------------------------------------------------------------------

_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;

    static char dllPaths [2][MAX_PATH] = {"", ""};

    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";

        // dllPaths[0] is relative to the TX Setup directory stored in the Registry

        char* path = dllPaths[0];

        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);

        // dllPaths[1] is relative to TXib.h file used in compilation

        path = dllPaths[1];

        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }

        if (char* dir = strrchr (path, '\\')) *dir = 0;

        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }

    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);

    if (arch)
        {
        assert (arch >= dllFileName);

        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));

        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }

    HMODULE   dll = GetModuleHandle (dllFileName);

    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);

    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);

        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);

        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }

    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);

    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;

    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);

    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè
#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó) [0])
        {
        case 192: {$ codePage =  1251; sCodePage = "1251.";          break; }
        case 208: {$ codePage = 65001; sCodePage = "UTF-8.";         break; }
        case 128: {$ codePage =   866; sCodePage = "866.";           break; }
        case 225: {$ codePage = 20866; sCodePage = "KOI-8, waaat?!"; break; }
        default:  {$ codePage =    -1; sCodePage = "(Unknown)";      break; }
        }
 
$   if (codePage != needCP && verbose)
        {
$       *_txTraceSE = ' ';  // No stack trace please
 
$       _TX_UNEXPECTED ("\v\t" "\n\n" "WARNING: CHECK TXLib.h file CODEPAGE. Maybe it is %s It should be %d.\n\n"
                        "This is NOT an error of TXLib itself. Please note:\n\n"
                        "Do NOT copy-and-paste TXLib.h file contents into a new file and them save it inside your "
                        "IDE or editor. This can change original TXLib codepage (%d) to another one. Instead, DO "
                        "use copy / move / cut-and-paste operations in Windows Explorer (Far Manager etc) only. "
                        "Or, when you see TXLib.h being opened in browser, use 'Save as...' (Ctrl+S) command.\n\n"
                        "Now you should re-download TXLib.h file from the http://txlib.ru site.\n\n"
                        "You can continue, but Russian messages and symbols may appear unreadable.",
                        sCodePage, needCP, needCP);
        }
 
$   return (codePage == needCP);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
_tx_FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
    {
    if (_TX_ARGUMENT_FAILED (dllFileName && *dllFileName)) return NULL;
    if (_TX_ARGUMENT_FAILED (funcName    && *funcName))    return NULL;
 
    static char dllPaths [2][MAX_PATH] = {"", ""};
 
    if (!*dllPaths[0])
        {
        const char dllDir[]  = "\\Windows\\";
 
        // dllPaths[0] is relative to the TX Setup directory stored in the Registry
 
        char* path = dllPaths[0];
 
        txRegQuery ("HKCU\\Software\\TX Library", "ProductDir", path, MAX_PATH);
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
 
        // dllPaths[1] is relative to TXib.h file used in compilation
 
        path = dllPaths[1];
 
        if (strchr (__FILE__, ':'))
            {
            strncpy_s (path, MAX_PATH, __FILE__, sizeof (__FILE__) - 1);
            }
        else
            {
            GetCurrentDirectory (MAX_PATH, path);
            strncat_s (path, MAX_PATH, "\\" __FILE__, sizeof ("\\" __FILE__) - 1);
            }
 
        if (char* dir = strrchr (path, '\\')) *dir = 0;
 
        strncat_s (path, MAX_PATH, dllDir, sizeof (dllDir) - 1);
        }
 
    char dllName[MAX_PATH] = "", dllArch[MAX_PATH] = "";
    const char* arch = (dllFileName? strchr (dllFileName, '*') : NULL);
 
    if (arch)
        {
        assert (arch >= dllFileName);
 
        strncpy_s (dllName, sizeof (dllName), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllName, sizeof (dllName), arch+1, sizeof (dllName) - 1 - strlen (dllName));
 
        strncpy_s (dllArch, sizeof (dllArch), dllFileName, (size_t) (arch - dllFileName));
        strncat_s (dllArch, sizeof (dllArch), sizeof (void*) == 8? "64" : "32", 3);
        strncat_s (dllArch, sizeof (dllArch), arch+1, sizeof (dllArch) - 1 - strlen (dllArch));
        }
    else if (dllFileName)
        {
        strncat_s (dllName, sizeof (dllName), dllFileName, sizeof (dllName) - 1);
        }
 
    HMODULE   dll = GetModuleHandle (dllFileName);
 
    if (!dll) dll = GetModuleHandle (dllArch);
    if (!dll) dll = GetModuleHandle (dllName);
 
    for (int i = 0; !dll && i < (int) sizearr (dllPaths); i++)
        {
        char path [MAX_PATH] = "";
        strncpy_s (path, sizeof (path), dllPaths[i], sizeof (dllPaths[i]));
        size_t len = strlen (path);
 
        strncpy_s (path + len, sizeof (path) - len, dllArch, sizeof (dllArch));
        if (!dll) dll = LoadLibrary (path);
 
        strncpy_s (path + len, sizeof (path) - len, dllName, sizeof (dllName));
        if (!dll) dll = LoadLibrary (path);
        }
 
    if (!dll) dll = LoadLibrary (dllArch);
    if (!dll) dll = LoadLibrary (dllName);
 
    if (!dll  && required) TX_ERROR ("\a" "Cannot load library \"%s%s%s\".",
                                           dllName, (arch? "\" / \"" : ""), dllArch);
    if (!dll) return NULL;
 
    _tx_FARPROC addr = (_tx_FARPROC) GetProcAddress (dll, funcName);
 
    if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s%s%s\".",
                                           funcName, dllName, (arch? "\" / \"" : ""), dllArch);
    return addr;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_MSC_VER) && (_MSC_VER == 1800) // MSVC 2013
    #pragma warning (push)
    #pragma warning (disable: 6102)          // Èñïîëüçîâàíèå 'name' èç çàâåðøèâøåãîñÿ îøèáêîé âûçîâà ôóíêöèè#endif

int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;

    HKEY hive = NULL;

    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )

    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;

    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }

    #undef EQU_

    keyName = strchr (keyName, '\\') + 1;

    HKEY  key  = NULL;
    DWORD size = 0;

    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);

    return size;
    }

#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif

//}
//-----------------------------------------------------------------------------------------------------------------

HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();

$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }

$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }

$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }

$   _txRunning = false;

    // Store the size

$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }

    // In Thread, where REAL creation lies...

$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);

$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;

$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);

$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;

$   HWND console = Win32::GetConsoleWindow();

$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);

$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }

$   Win32::GdiSetBatchLimit (1);

$   SetLastError (0);

$   errno = 0;

    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;

$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;

$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;

$   _txWaitFor (wnd, 5*_TX_TIMEOUT);

$   return wnd;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;

$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };

$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);

$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };

//{ Set defaults for graphics layer

$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;

$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;

$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;

$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;

//}

$   if (dc != txDC())
        {$ return true; }

//{ Set defaults for console  layer

$   POINT szCanvas = txGetExtent (dc);

$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}

//{ Scroll the console for text to go above top of window and don't mix with graphics

$   if (con.dwCursorPosition.X) _putch ('\n');

$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);

$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);

$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up

$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);

$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}

$   txUpdateWindow (true);

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()

    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }

//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------

// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().

void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);

    Win32::exit (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);

    Win32::ExitProcess (retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }

$5  _txCleanup();

    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);

    return Win32::TerminateProcess (process, retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);

$5  _txCleanup();

    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));

    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//-----------------------------------------------------------------------------------------------------------------

BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);

$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:

        default:                  break;
        }

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;

$3  _txRunning = false;
$   _txConsole_IsBlinking = false;

$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();

$   HWND wnd        = (canvas)? canvas : console;

$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;

$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }

$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }

$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }

$   _flushall();

$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }

$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }

$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }

$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);

$   txSpeak     (NULL);
$   txPlayVideo (NULL);

$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }

$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }

$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }

$   console = Win32::GetConsoleWindow();

$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }

$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);

$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }

$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();

$   _txSymGetFromAddr (NULL);

    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));

$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }

//-----------------------------------------------------------------------------------------------------------------

int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));

$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }

        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };

$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";

$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;

$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);

$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;

$   return 2;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;

$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();

$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }

$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);

        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide

        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.

        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.

        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed

        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }

        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }

        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }

$   while (!wine && _kbhit()) (void)_getch();

$   fprintf (stderr, "\n");
    }

//-----------------------------------------------------------------------------------------------------------------

int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);

$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }

$   if (_kbhit())
        {
$       return _getch();
        }

#if defined (_MSC_VER) && (_MSC_VER < 1700)

$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }

#endif

$   return EOF;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;

$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;

$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;

$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent

$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;

$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');

$       if (gp)
            {
$           *gp++ = 0;

$           if (_stricmp (p, parent) != 0) { continue; }

$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }

$   return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;

$   Sleep (*(int*) timeout);

$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);

$       _txKillProcess (parent);

$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }

    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------

PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;

$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;

$   CloseHandle (sshot);

$   return &info;
    }

//-----------------------------------------------------------------------------------------------------------------

// You are here, little hacker?

bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;

$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;

$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;

$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};

$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;

$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;

$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...

    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?

$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;

$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;

$   int killed = 0;

$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;

        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }

        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }

        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }

            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }

        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }

$   CloseHandle (sshot);

$   return killed;

    #undef name
    #undef cmdLine
    #undef pid
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;

$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }

$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }

$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;

    // Should use ReadProcessMemory() because the info is actually in another address space

$   bool ok = true;

$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }

$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }

$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )

IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);

$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);

$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// TXLib continues to hack the reality to make your life better, sweeter and easier

uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);

$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;

$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;

$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;

$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)

$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;

        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.

$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;

$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);

$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);

$       return (uintptr_t) oldFunc;
        }

//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.

$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }

$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);

$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;

$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;

    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;

$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);

             thunk0 && thunk1 && thunk1->u1.Function;

             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr

            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);

            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }

$       if (found) break;
        }

    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;

$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;

$   *(uintptr_t*) impPtr = newFunc;

$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);

$   return (uintptr_t) oldFunc;
    }

#undef RVA_

//-----------------------------------------------------------------------------------------------------------------

bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };

$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;

$   bool inDll = false;

$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;

$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);

$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);

$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }

$   CloseHandle (sshot);
$   return inDll;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();

$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&

           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;

    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr

    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;

    return !(mbi.Protect & readRights);
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//! @name    Âíóòðåííèå ôóíêöèè îêíà TXLib       (_txCanvas...)
//=================================================================================================================

unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR

$8  _txCanvas_ThreadId = GetCurrentThreadId();

$   if (_TX_ARGUMENT_FAILED (data)) return false;

$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));

$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;

$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");

$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));

    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }

$   Win32::GdiSetBatchLimit (1);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));

$   SetForegroundWindow (wnd);

$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);

$   _txRunning = true;

$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }

        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }

$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);

$       Sleep (0);
        }

$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.

$   LeaveCriticalSection (&_txCanvas_LockBackBuf);

    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));

$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }

$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }

$   _txCanvas_ThreadId = 0;
$   return true;

    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }

//-----------------------------------------------------------------------------------------------------------------

HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;

$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }

$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };

$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;

$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }

$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }

$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;

$   return txWindow();
    }

//-----------------------------------------------------------------------------------------------------------------

const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);

$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };

$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);

$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);

$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }

$   return (const char*)(uintptr_t) atom;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;

$   _txCanvas_RefreshLock = count;

$   HWND wnd = txWindow();

$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   return oldCount;
    }

//-----------------------------------------------------------------------------------------------------------------

HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;

$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";

$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";

$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };

$   const unsigned char* image = (size == 32)? image32 : image16;

$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);

$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));

        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }

$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };

$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);

$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;

$   return icon;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//! @name    Ñîáûòèÿ îñíîâíîãî îêíà              (_txCanvas_On...)
//=================================================================================================================
//! @{

LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)

    int inTX = _txLoc::Cur.inTX++;

    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;

#endif

$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }

    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }

    static bool bkErased = false;

    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }

        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }

        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }

        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }

        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }

        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }

        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }

        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }

        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }

        default: break;
        }

    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }

        default: break;
        }

$   return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);

$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);

$   _txCanvas_UserDCs = new ::std::vector <HDC>;

$   _txCanvas_Window = wnd;

$   txSetDefaults();

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé

$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
#endif
 
int txRegQuery (const char* keyName, const char* valueName, void* value, size_t szValue)
    {
    if (_TX_ARGUMENT_FAILED (keyName)) return 0;
 
    HKEY hive = NULL;
 
    #define EQU_(name1, name2)  ( _strnicmp (keyName, name1 "\\", sizeof (name1)) == 0 || \
                                  _strnicmp (keyName, name2 "\\", sizeof (name2)) == 0 )
 
    if      (EQU_("HKLM", "HKEY_LOCAL_MACHINE"))  hive = HKEY_LOCAL_MACHINE;
    else if (EQU_("HKCU", "HKEY_CURRENT_USER"))   hive = HKEY_CURRENT_USER;
    else if (EQU_("HKCR", "HKEY_CLASSES_ROOT"))   hive = HKEY_CLASSES_ROOT;
    else if (EQU_("HKU",  "HKEY_USERS"))          hive = HKEY_USERS;
    else if (EQU_("HKCC", "HKEY_CURRENT_CONFIG")) hive = HKEY_CURRENT_CONFIG;
 
    else { _TX_ARGUMENT_FAILED (("keyName äîëæíî íà÷èíàòüñÿ ñ HKLM\\, HKCU\\, HKCR\\, HKU\\ èëè HKCC\\ ", hive)); return 0; }
 
    #undef EQU_
 
    keyName = strchr (keyName, '\\') + 1;
 
    HKEY  key  = NULL;
    DWORD size = 0;
 
    bool                               ok  = !!RegOpenKeyEx    (hive, keyName,   0, KEY_QUERY_VALUE, &key)         == ERROR_SUCCESS;
    if (ok)                            ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, NULL,          &size) == ERROR_SUCCESS;
    if (ok && value && size < szValue) ok &= !!RegQueryValueEx (key,  valueName, NULL, NULL, (BYTE*) value, &size) == ERROR_SUCCESS;
    if (key)                           ok &= !!RegCloseKey     (key);
 
    return size;
    }
 
#if defined (_MSC_VER) && (_MSC_VER == 1800)
    #pragma warning (pop)
#endif
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
    {
$1  if (!_txInitialized) _txInitialized = _txInitialize();
 
$   if (HWND wnd = txWindow())
        {
$       SetLastErrorEx (ERROR_INVALID_DATA, 0);
$       _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî!"));
$       return wnd;
        }
 
$   if (!_txIsDll)
        {
$       _txMain = ! FindAtom ("_txMain");  // Not a thread-safe
$       (void)       AddAtom ("_txMain");
        }
 
$   if (_txWindowUpdateInterval < 10) {$ _txWindowUpdateInterval = 10; }
 
$   _txRunning = false;
 
    // Store the size
 
$   static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$   if (centered) { size.cx *= -1; size.cy *= -1; }
 
    // In Thread, where REAL creation lies...
 
$   unsigned id = 0;
$   _txCanvas_Thread = (HANDLE) Win32::_beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);
 
$   if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."),  (HWND) NULL;
 
$   _txWaitFor (_txRunning, 10*_TX_TIMEOUT);
 
$   if (!_txRunning)       return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."), (HWND) NULL;
$   if (!txOK())           return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."),     (HWND) NULL;
 
$   HWND console = Win32::GetConsoleWindow();
 
$   DWORD proc = 0;
$   GetWindowThreadProcessId (console, &proc);
 
$   if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
        {$ ShowWindow (console, _txConsoleMode); }
 
$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (menu) {$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED)); }
 
$   Win32::GdiSetBatchLimit (1);
 
$   SetLastError (0);
 
$   errno = 0;
 
    #if !defined (__CYGWIN__)
$   _doserrno = 0;
    #endif
 
$   return txWindow();
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
HWND txCreateExtraWindow (CREATESTRUCT createData)
    {
$1  if (_TX_TXWINDOW_FAILED()) return NULL;
 
$   volatile HWND wnd = NULL;
$   createData.hInstance = (HINSTANCE)(uintptr_t) &wnd;
 
$   PostMessage (txWindow(), _TX_WM_CREATEWND, 0, (LPARAM) &createData) asserted;
 
$   _txWaitFor (wnd, 5*_TX_TIMEOUT);
 
$   return wnd;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txSetDefaults (HDC dc /*= txDC()*/)
    {
$1  if (dc == txDC()) txUpdateWindow (false);
$   txAutoLock _lock;
 
$   RECT r = {};
$   GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$   SIZE szCon = { r.right - r.left, r.bottom - r.top };
 
$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);
 
$   CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$   GetConsoleScreenBufferInfo (out, &con);
 
$   SIZE szTxt = { (short) (con.srWindow.Right  - con.srWindow.Left + 1),
                   (short) (con.srWindow.Bottom - con.srWindow.Top  + 1) };
 
//{ Set defaults for graphics layer
 
$   _txBuffer_Select (Win32::GetStockObject (WHITE_PEN),   dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), dc) asserted;
 
$   _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
                                         0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                         RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                         DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont),
                      dc) asserted;
 
$  (Win32::SetTextColor      (dc, TX_WHITE) != CLR_INVALID) asserted;
$   Win32::SetBkMode         (dc, TRANSPARENT)              asserted;
 
$   Win32::SetROP2           (dc, R2_COPYPEN)               asserted;
$   Win32::SetStretchBltMode (dc, HALFTONE)                 asserted;
 
//}
 
$   if (dc != txDC())
        {$ return true; }
 
//{ Set defaults for console  layer
 
$   POINT szCanvas = txGetExtent (dc);
 
$   HGDIOBJ font = txFontExist (_txConsoleFont)?
                       Win32::CreateFont (szCanvas.y/szTxt.cy, szCanvas.x/szTxt.cx,
                                          0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
                                          RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                          DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
                       :
                       Win32::GetStockObject (SYSTEM_FIXED_FONT);
 
$   _txBuffer_Select (font, _txCanvas_BackBuf[1]);
//}
 
//{ Scroll the console for text to go above top of window and don't mix with graphics
 
$   if (con.dwCursorPosition.X) _putch ('\n');
 
$   short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);
 
$   con.srWindow.Top    = (short) (con.srWindow.Top    + delta);
$   con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);
 
$   SMALL_RECT src  = { 0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$   CHAR_INFO  fill = { {' '}, FOREGROUND_LIGHTGRAY };
$   COORD      dest = { 0, (short) -delta };  // New UL-corner of src, scroll up
 
$   con.dwCursorPosition.X = 0;
$   con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);
 
$   (con.srWindow.Bottom < con.dwSize.Y &&                        // Move the "window"
     SetConsoleWindowInfo      (out, true, &con.srWindow))
    ||
    (ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill),    // Or scroll the buffer
     SetConsoleCursorPosition  (out, con.dwCursorPosition));
//}
 
$   txUpdateWindow (true);
 
    return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline bool txOK()
    {
    return (_txCanaryFirst == 0x776F656D &&  // Too well-known values to use constants. You know these values, don't you?
            _txCanaryLast  == 0x5E2E2E5E &&
            _txCanvas_OK()
 
    #if defined (_MSC_VER)
         && _CrtCheckMemory()
    #endif
            );
    }
 
//-----------------------------------------------------------------------------------------------------------------
//{          Cleanup
//-----------------------------------------------------------------------------------------------------------------
 
// Implicit std(MSVCRT.dll)::_cexit() call before _txCleanup can lead to hangs in _cexit handlers chain.
// So redefining ::std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols
// if several modules linked together include TXLib.h. See _txSetProcAddress() call in _txInitialize().
 
void _txOnCExit()
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
 
$5  _txCleanup();
 
    txOutputDebugPrintf ("%s - WARNING: calling Win32::_cexit()\n", _TX_VERSION);
    _TX_CALLv (Win32::_cexit, ());
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnExit (int retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
        }
 
$5  _txCleanup();
 
    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::exit (%d)\n", _TX_VERSION, retcode);
 
    Win32::exit (retcode);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnExitProcess (unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (%u) called\n", _TX_VERSION, __func__, retcode);
        }
 
$5  _txCleanup();
 
    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::ExitProcess (%u)\n", _TX_VERSION, retcode);
 
    Win32::ExitProcess (retcode);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txOnTerminateProcess (HANDLE process, unsigned retcode)
    {
    if (retcode != 0)
        {
        OutputDebugString ("\n");
        txOutputDebugPrintf ("%s - WARNING: %s (0x%p, %u) called\n", _TX_VERSION, __func__, process, retcode);
        }
 
$5  _txCleanup();
 
    if (retcode != 0)
        txOutputDebugPrintf ("%s - WARNING: calling Win32::TerminateProcess (0x%p, %u)\n", _TX_VERSION, process, retcode);
 
    return Win32::TerminateProcess (process, retcode);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnFatalExit (int retcode)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%d) called\n", _TX_VERSION, __func__, retcode);
 
$5  _txCleanup();
 
    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalExit (%d)\n", _TX_VERSION, retcode);
    _TX_CALLv (Win32::FatalExit, (retcode));
 
    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (%d)\n", _TX_VERSION, retcode);
    Win32::TerminateProcess (GetCurrentProcess(), retcode);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnFatalAppExitA (unsigned action, const char message[])
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (%u, \"%s\") called\n", _TX_VERSION, __func__, action, message);
 
$5  _txCleanup();
 
    txOutputDebugPrintf ("%s - WARNING: calling Win32::FatalAppExitA (%u, %s)\n", _TX_VERSION, action, message);
    _TX_CALLv (Win32::FatalAppExitA, (action, message));
 
    txOutputDebugPrintf ("%s - WARNING: Win32::FatalExit() failure, calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION);
    Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
BOOL WINAPI _txOnConsoleCtrlEvent (DWORD type)
    {
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s (0x%04lX) called\n", _TX_VERSION, __func__, (unsigned long) type);
 
$5  switch (type)
        {
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT: $ _txExit = true;
                                  $ _txCleanup();
        case CTRL_C_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_BREAK_EVENT:
 
        default:                  break;
        }
 
$   return false;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txCleanup()
    {
    if (!_txInitialized) return;
    else _txInitialized = false;
 
$3  _txRunning = false;
$   _txConsole_IsBlinking = false;
 
$   HWND canvas     = txWindow();
$   HWND console    = Win32::GetConsoleWindow();
$   unsigned thread = GetCurrentThreadId();
 
$   HWND wnd        = (canvas)? canvas : console;
 
$   bool externTerm = (thread != _txMainThreadId &&
                       thread != _txCanvas_ThreadId);
$   DWORD parent = 0;
$   int  isParentWaitable = _txIsParentWaitable (&parent);
$   bool waitableParent   = !externTerm && isParentWaitable;
 
$   if (canvas)
        {$ txSleep (5*_txWindowUpdateInterval); }
 
$   if (_txConsole)
        {
$       if (_txMain) txSetConsoleAttr (FOREGROUND_LIGHTGRAY);
$       if (console) EnableWindow (console, true);
        }
 
$   if (_txMain && !externTerm && wnd != NULL)
        {$ _txSetFinishedText (wnd); }
 
$   _flushall();
 
$   bool paused = false;
$   if (((canvas? _txMain : _txConsole) && !_txExit) || (_txErrors && thread == _txMainThreadId))
        {
$       if (wnd)
            {
            if (isParentWaitable >= 0) {$ SetWindowPos (wnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
$           EnableWindow (wnd, true);
            }
 
$       if (console && isParentWaitable >= 0)
            {
$           _txPauseBeforeTermination (canvas);
$           paused = true;
            }
        }
 
$   if (txWindow())
        {$ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }
 
$   _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);
 
$   txSpeak     (NULL);
$   txPlayVideo (NULL);
 
$   if (GetCurrentThreadId() != _txMainThreadId)
        {$ SuspendThread (_txMainThread);    }
$   if (GetCurrentThreadId() != _txCanvas_ThreadId)
        {$ SuspendThread (_txCanvas_Thread); }
 
$   if (_txMainThread)
        {$ CloseHandle (_txMainThread)    asserted; _txMainThread    = NULL; }
$   if (_txCanvas_Thread)
        {$ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }
 
$   if (!txWindow())
        {$ DeleteCriticalSection (&_txCanvas_LockBackBuf); CRITICAL_SECTION zero = {0, -1}; _txCanvas_LockBackBuf = zero; }
 
$   console = Win32::GetConsoleWindow();
 
$   if (_txMain && _txConsole)
        {$ _txConsole_Detach (waitableParent && !externTerm); }
 
$   bool parentKilled = false;
$   if (waitableParent && paused && _txNOP (_TX_ALLOW_KILL_PARENT))
        {
$       parentKilled = _txKillProcess (parent);
 
$       parent = 0;
$       if (!parentKilled || _txIsParentWaitable (&parent))
            {$ PostMessage (console, WM_CHAR, '\n', 0); }
        }
 
$   std::cout.flush();
$   std::cerr.flush();
$   std::clog.flush();
$   _flushall();
 
$   _txSymGetFromAddr (NULL);
 
    _TX_ON_DEBUG (OutputDebugString ("\n");
                  OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
                  OutputDebugString ("\n"));
 
$   if (parentKilled && _txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int _txSetFinishedText (HWND wnd)
    {
    struct tools
        {
        static LRESULT getWindowText (HWND window, wchar_t text[], size_t size)
            {
$3          memset (text, 0, size * sizeof (*text));
 
$           return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
 
        static LRESULT setWindowText (HWND window, wchar_t text[])
            {
$1          return SendMessageTimeoutW (window, WM_SETTEXT, 0,             (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
            }
        };
 
$1  static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";
 
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   int len = (int) wcslen (title); if (len >= (int)_TX_BUFSIZE) len = _TX_BUFSIZE-1;
 
$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, (int)_TX_BUFSIZE - len);
 
$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == (wchar_t) 0x0417 /* 'Ç' */) return 0;
 
$   MultiByteToWideChar (_TX_CODEPAGE, 0, " [FINISHED]",  -1, title + len, (int)_TX_BUFSIZE - len);
 
$   tools::setWindowText (wnd, title);
$   tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$   if (len <= (int)_TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;
 
$   return 2;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txPauseBeforeTermination (HWND canvas)
    {
$3  while (_kbhit()) (void)_getch();
 
$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$   bool kbWait  = (_txGetInput() == EOF);
$   bool wine    = !!Win32::wine_get_version;
 
$   if (kbWait && !canvas && !kbRedir && !wine)
        {
$       txSetLocale();
 
$       fprintf (stderr, (!_txErrors? "\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]" :
                                      "\n" "[Press F to Pay Respects...]"));  // https://knowyourmeme.com/memes/press-f-to-pay-respects
$       fflush  (stderr);
        }
 
$   for (int i = 1; ; i++)
        {
$       Sleep (_txWindowUpdateInterval);
 
        if (!kbWait || (kbRedir && !canvas)) {$ break; }  // No need to run and hide
 
        if (!wine && _txGetInput() != EOF)   {$ break; }  // Somebody hit something.
 
        if (canvas && !_txCanvas_ThreadId)   {$ break; }  // There was a window, and now there is not.
 
        if (!Win32::GetConsoleWindow())      {$ break; }  // Console was destroyed
 
        if (_TX_CALL (Win32::GhostWindowFromHungWindow, (canvas)))
            {$ TX_ERROR ("Ïðîãðàììà çàâèñëà è áóäåò çàâåðøåíà."); break; }
 
        if (canvas && _TX_CALL (Win32::IsHungAppWindow, (canvas)))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà-òàêè çàâèñëà è áóäåò çàâåðøåíà."); break; }
 
        if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
            {$ _txTrace (__FILE__, __LINE__, NULL, "WARNING: Ïðîãðàììà íå îòâå÷àåò è áóäåò çàâåðøåíà.");  break; }
 
        if (!wine && !(i % 100500))
            {$ fprintf (stderr, "\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
        }
 
$   while (!wine && _kbhit()) (void)_getch();
 
$   fprintf (stderr, "\n");
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int _txGetInput()
    {
$4  HANDLE con = GetStdHandle (STD_INPUT_HANDLE);
 
$   DWORD nChars = 0;
$   if (GetConsoleMode (con, &nChars) == 0 &&
        PeekNamedPipe  (con, NULL, 0, NULL, &nChars, NULL))
        {
$       return (nChars)? fgetc (stdin) : EOF;
        }
 
$   if (_kbhit())
        {
$       return _getch();
        }
 
#if defined (_MSC_VER) && (_MSC_VER < 1700)
 
$   if (fseek (stdin, 1, SEEK_CUR) != EOF)
        {
$       (void) fseek (stdin, -1, SEEK_CUR);
$       return fgetc (stdin);                              // This causes blocking in MSVC 2011 beta
        }
 
#endif
 
$   return EOF;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
    {
$4  PROCESSENTRY32* info = _txFindProcess();
$   if (!info) return 0;
 
$   info = _txFindProcess (info->th32ParentProcessID);
$   if (!info) return 0;
 
$   char parent [MAX_PATH] = "";
$   strncpy_s (parent, sizeof (parent), info->szExeFile, sizeof (parent) - 1);
$   if (parentPID) *parentPID = info->th32ProcessID;
 
$   info = _txFindProcess (info->th32ParentProcessID);          // info: grandparent
 
$   char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$   char* ctx = NULL;
 
$   for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
        {
$       char* gp = strchr (p, ':');
 
$       if (gp)
            {
$           *gp++ = 0;
 
$           if (_stricmp (p, parent) != 0) { continue; }
 
$           if (info) if (_stricmp (gp, info->szExeFile) == 0)  // Was &&, but MSVC /analyze is so paranoid
                {$ return islower ((unsigned char) *gp)? +1 : -1; }
            }
        else
            {
$           if (_stricmp (p, parent) == 0)
                {$ return islower ((unsigned char)  *p)? +1 : -1; }
            }
        }
 
$   return 0;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txWatchdogTerminator (void* timeout)  // Or Watchcat? Possibly will change in future versions
    {
$3  if (_TX_ARGUMENT_FAILED (timeout)) return;
 
$   Sleep (*(int*) timeout);
 
$   OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: %s(): Timeout (%d) expired, activating. %s\n",  // Kinda static reflection...
                         _TX_VERSION, __func__, *(int*) timeout, ((__func__[8] == 'd')? "Bark, bark" : "Meow, meow"));
$   DWORD parent = 0;
$   if (_txIsParentWaitable (&parent))
        {
        txOutputDebugPrintf ("%s - WARNING: %s(): Calling _txKillProcess (0x%04lu)\n",
                             _TX_VERSION, __func__, (unsigned long) parent);
 
$       _txKillProcess (parent);
 
$       PostMessage (GetConsoleWindow(), WM_CHAR, '\n', 0);
        }
 
    txOutputDebugPrintf ("%s - WARNING: %s(): Calling Win32::TerminateProcess (EXIT_FAILURE)\n", _TX_VERSION, __func__);
$   Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
    }
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{          Tools
//-----------------------------------------------------------------------------------------------------------------
 
PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
    {
$4  static PROCESSENTRY32 info = { sizeof (info) };
$   if (!pid) return &info;
 
$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return NULL;
 
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        if (info.th32ProcessID == pid) break;
 
$   CloseHandle (sshot);
 
$   return &info;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
// You are here, little hacker?
 
bool _txKillProcess (DWORD pid)
    {
$3  if (_TX_ARGUMENT_FAILED (pid)) return false;
 
$   HANDLE token = INVALID_HANDLE_VALUE;
$   OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;
 
$   LUID luid = {};
$   LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;
 
$   TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$   TOKEN_PRIVILEGES old  = {};
 
$   DWORD oldSz = 0;
$   AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;
 
$   HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$   if (!proc) return false;
 
$   bool ok = !!Win32::TerminateProcess (proc, 0);
$   CloseHandle (proc);
 
$   return ok;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int txTaskKill (const char i[] /*= NULL*/,
                const char doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine[] /*= NULL*/,
                unsigned   x   /*= 0*/)
    {
    // ...so tired of it already...
 
    #define name          i  // Great name!
    #define cmdLineSubstr doYouWantToFindSomethingInTheCommandLineIDidSomethingForYouToFindSomethingInTheCommandLineMaybeYouWillFindSomeInterestingInTheCommandLineSoIDidSomethingForYouInTheCommandLine
    #define pid           x  // Another great name, isn't it?
 
$3  if (_TX_ARGUMENT_FAILED ((name || cmdLineSubstr || pid) && "Âîò òàêèå òóò èíòåðåñíûå èìåíà âñòðå÷àþòñÿ...")) return false;
 
$   wchar_t cmdLineSubstrW[_TX_BUFSIZE] = L"";
    if (cmdLineSubstr) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, cmdLineSubstr, -1, cmdLineSubstrW, sizearr (cmdLineSubstrW)); }
 
$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$   assert (sshot); if (!sshot) return 0;
 
$   int killed = 0;
 
$   PROCESSENTRY32 info = { sizeof (info) };
$   for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
        {
        bool kill = false;
 
        if (!kill && pid  && info.th32ParentProcessID        == pid) {$ kill = true; }
 
        if (!kill && name && _stricmp (info.szExeFile, name) == 0)   {$ kill = true; }
 
        if (!kill)
            {
            wchar_t cmdLineW[_TX_BUFSIZE] = L"";
            if (!_txGetCommandLine (cmdLineW, sizearr (cmdLineW), info.th32ProcessID)) { continue; }
 
            if (*cmdLineW && stristrw (cmdLineW, cmdLineSubstrW))    {$ kill = true; }
            }
 
        if (kill)
            {
$           if (_txKillProcess (info.th32ProcessID))
                {$ killed++; }
            }
        }
 
$   CloseHandle (sshot);
 
$   return killed;
 
    #undef name
    #undef cmdLine
    #undef pid
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txGetCommandLine (wchar_t cmdLine[], size_t szCmdLine, unsigned pid /*= _getpid()*/)
    {
$4  if (_TX_ARGUMENT_FAILED (cmdLine))        return false;
$   if (_TX_ARGUMENT_FAILED (szCmdLine >= 2)) return false;
 
$   if (pid == (unsigned) _getpid())
        {
$       wcsncpy_s (cmdLine, szCmdLine, GetCommandLineW(), szCmdLine-1);
$       return true;
        }
 
$   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
    if (!proc) {$ return false; }
 
$   Win32::PROCESS_BASIC_INFORMATION pbi = {};
$   Win32::NtQueryInformationProcess (proc, 0 /*ProcessBasicInformation*/, &pbi, sizeof (pbi), NULL) == 0 asserted;
 
    // Should use ReadProcessMemory() because the info is actually in another address space
 
$   bool ok = true;
 
$   Win32::PEB peb = {};
    if (ok && pbi.PebBaseAddress)        {$ ok &= !!ReadProcessMemory (proc, pbi.PebBaseAddress,        &peb,    sizeof (peb),    NULL); }
 
$   Win32::RTL_USER_PROCESS_PARAMETERS params = {};
    if (ok && peb.ProcessParameters)     {$ ok &= !!ReadProcessMemory (proc, peb.ProcessParameters,     &params, sizeof (params), NULL); }
 
$   *cmdLine = 0;
    if (ok && params.CommandLine.Buffer) {$ ok &= !!ReadProcessMemory (proc, params.CommandLine.Buffer, cmdLine,
                                                                       MIN  (params.CommandLine.Length + 2, (int) (szCmdLine * sizeof (*cmdLine)) - 2),
                                                                       NULL); }
$   CloseHandle (proc) asserted;
 
$   return ok;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
#define RVA_(type, module, addr)  ( (type) ((uintptr_t) (module) + (uintptr_t) (addr)) )
 
IMAGE_NT_HEADERS* _txGetNtHeaders (HMODULE module /*= GetModuleHandle (NULL)*/)
    {
$4  assert (module);
 
$   IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, module, 0);
$   IMAGE_NT_HEADERS* ntHdr  = RVA_ (IMAGE_NT_HEADERS*, module, dosHdr->e_lfanew);
 
$   return (dosHdr->e_magic  == IMAGE_DOS_SIGNATURE &&
            ntHdr->Signature == IMAGE_NT_SIGNATURE)? ntHdr : NULL;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
// TXLib continues to hack the reality to make your life better, sweeter and easier
 
uintptr_t _txSetProcAddress (const char funcName[], uintptr_t newFunc, const char dllName[] /*= NULL*/, int useHotPatching /*= false*/,
                             HMODULE module /*= NULL*/, bool debug /*= false*/)
    {
$4  if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p):\n", funcName, (void*) newFunc, dllName, module);
 
$   if (_TX_ARGUMENT_FAILED (funcName)) return 0;
$   if (_TX_ARGUMENT_FAILED (newFunc))  return 0;
 
$   if (!module) module = GetModuleHandle (NULL);
$   if (!module) return 0;
 
$   HMODULE dll     = (dllName)? GetModuleHandle (dllName)       : NULL;
$   PROC    oldFunc = (dll)?     GetProcAddress  (dll, funcName) : NULL;
 
$   if (useHotPatching && oldFunc)
        {
$       const size_t jmpSz = 1 + sizeof (DWORD);  // sizeof (JMP rel instruction)
 
$       DWORD oldRights = 0;
$       if (!VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, PAGE_EXECUTE_READWRITE, &oldRights)) return 0;
 
        // Overwrite oldFunc prolog with JMP trampoline to newFunc.
        // Calling oldFunc from any location will lead to newFunc call anyway.
 
$       *(BYTE*)  ((char*)(uintptr_t) oldFunc + 0) = 0xE9;  // JMP rel
$       *(DWORD*) ((char*)(uintptr_t) oldFunc + 1) = ((char*)(uintptr_t) newFunc - (char*)(uintptr_t) oldFunc - jmpSz) & 0xFFFFFFFF;
 
$       FlushInstructionCache (GetCurrentProcess(), (void*)(uintptr_t) oldFunc, jmpSz);
 
$       VirtualProtect ((void*)(uintptr_t) oldFunc, jmpSz, oldRights, &oldRights);
 
$       return (uintptr_t) oldFunc;
        }
 
//  For PE structure and Import Table format, e.g. see https://books.google.ru/books?id=ifQPC86G66sC&pg=PA255
//  and below through Figure 5-5, and/or http://www.brokenthorn.com/Resources/OSDevPE.html.
 
$   IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders (module);
    if (!ntHdr || (ntHdr ->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)) {$ return 0; }
 
$   DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$   IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, module, impOffset);
 
$   if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return 0;
 
$   IMAGE_THUNK_DATA* thunk0 = NULL, * thunk1 = NULL;
$   char*  impDll  = NULL;
$   char*  impName = NULL;
$   void** impPtr  = NULL;
$   bool   found   = false;
 
    for (; desc->Name; desc++)
        {
$       impDll = RVA_ (char*, module, desc->Name);
$       if (dllName && _stricmp (impDll, dllName) != 0) continue;
 
$       for (thunk0 = RVA_ (IMAGE_THUNK_DATA*, module, desc->OriginalFirstThunk),
             thunk1 = RVA_ (IMAGE_THUNK_DATA*, module, desc->FirstThunk);
 
             thunk0 && thunk1 && thunk1->u1.Function;
 
             thunk0++,
             thunk1++)
            {
            impName = (char*) RVA_ (IMAGE_IMPORT_BY_NAME*, module, thunk0->u1.AddressOfData) -> Name;
            impPtr  = (void**)(uintptr_t)                         &thunk1->u1.Function;  // Should change it, so this is ptr
 
            if (debug) txOutputDebugPrintf ("[0x%p] %s!%s\n", *impPtr, impDll, impName);
 
            if ((oldFunc && (uintptr_t) oldFunc == (uintptr_t) *impPtr) ||
                (impName && _stricmp (funcName, impName) == 0))
                {
                found = true;
                break;
                }
            }
 
$       if (found) break;
        }
 
    if (debug) txOutputDebugPrintf ("_txSetProcAddress (%s, 0x%p, %s, 0x%p): %s\n\n",
                                    funcName, (void*) newFunc, dllName, module, (found? "FOUND" : "NOT found"));
$   if (!found) return 0;
 
$   DWORD rights = PAGE_READWRITE;
$   if (!VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights)) return 0;
 
$   *(uintptr_t*) impPtr = newFunc;
 
$   VirtualProtect (impPtr, sizeof (*impPtr), rights, &rights);
 
$   return (uintptr_t) oldFunc;
    }
 
#undef RVA_
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txInDll()
    {
$4  MODULEENTRY32 mod = { sizeof (mod) };
 
$   HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$   assert (sshot); if (!sshot) return false;
 
$   bool inDll = false;
 
$   for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
        {
$       if (!mod.modBaseAddr) continue;
 
$       IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders ((HMODULE) mod.modBaseAddr);
 
$       inDll = ntHdr && ((ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);
 
$       if (In (std::nomeow, (BYTE*)(uintptr_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize))
            {$ break; }
        }
 
$   CloseHandle (sshot);
$   return inDll;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txIsConsoleSubsystem()
    {
$4  IMAGE_NT_HEADERS* ntHdr = _txGetNtHeaders();
 
$   return  ntHdr &&
            ntHdr ->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC &&
 
           (ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI ||
            ntHdr ->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_POSIX_CUI);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txIsBadReadPtr (const void* address)
    {
    MEMORY_BASIC_INFORMATION mbi = {};
    if (!VirtualQuery (address, &mbi, sizeof (mbi))) return true;
 
    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS))  return true;  // Guard page -> bad ptr
 
    DWORD readRights = PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;
 
    return !(mbi.Protect & readRights);
    }
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Internal TXLib window functions     (_txCanvas...)
//=================================================================================================================
 
unsigned WINAPI _txCanvas_ThreadProc (void* data)
    {
    #define SetClassLong_  SetClassLongPtr
    #define GCL_HICON_     GCLP_HICON
    #define GCL_HICONSM_   GCLP_HICONSM
    #define GCL_HCURSOR_   GCLP_HCURSOR
 
$8  _txCanvas_ThreadId = GetCurrentThreadId();
 
$   if (_TX_ARGUMENT_FAILED (data)) return false;
 
$   unsigned long stackSize = _TX_STACKSIZE;
$   _TX_CALL (Win32::SetThreadStackGuarantee, (&stackSize));
 
$   HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$   if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas!"), 0;
 
$   HICON   icon32 = LoadIcon         (NULL, "_TX_ICON");
$   HICON   icon16 = LoadIcon         (NULL, "_TX_ICONSM");
$   HCURSOR cursor = LoadCursor       (NULL, "_TX_CURSOR");
$   HMENU   menu   = LoadMenu         (NULL, "_TX_MENU");
$   HACCEL  accel  = LoadAccelerators (NULL, "_TX_ACCELERATORS");
 
$   SetClassLong_ (wnd, GCL_HICON_,   (LONG_PTR) (icon32? icon32 : _txCreateTXIcon (32)));
$   SetClassLong_ (wnd, GCL_HICONSM_, (LONG_PTR) (icon16? icon16 : _txCreateTXIcon (16)));
$   SetClassLong_ (wnd, GCL_HCURSOR_, (LONG_PTR) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));
 
    if (menu) {$ SetMenu (wnd, menu); DrawMenuBar (wnd); }
 
$   Win32::GdiSetBatchLimit (1);
 
    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));
 
$   SetForegroundWindow (wnd);
 
$   ShowWindow          (wnd, SW_SHOW);
$   UpdateWindow        (wnd);
 
$   _txRunning = true;
 
$   MSG msg = {};
$   while (GetMessage (&msg, NULL, 0, 0))
        {
        if (!msg.hwnd) {$ continue; }
 
        if (accel && TranslateAccelerator (wnd, accel, &msg)) {$ continue; }
 
$       TranslateMessage (&msg);
$       DispatchMessage  (&msg);
 
$       Sleep (0);
        }
 
$   if (icon16) DestroyIcon (icon16);  // If Explorer is displaying Tray Notification, these
$   if (icon32) DestroyIcon (icon32);  // calls will possibly fail, and we'll get resource leak.
 
$   LeaveCriticalSection (&_txCanvas_LockBackBuf);
 
    _TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));
 
$   if (_txWatchdogTimeout >= 0)
        {$ Win32::_beginthread (_txWatchdogTerminator, 0, &_txWatchdogTimeout); }
 
$   if (_txRunning && _txMain)         // Main window is destroyed but main() is still running.
        {                              // No chances for good termination, so use exit().
$       _txCleanup();
$       ::exit ((int) msg.wParam);
        }
 
$   _txCanvas_ThreadId = 0;
$   return true;
 
    #undef SetClassLong
    #undef GCL_HICON_
    #undef GCL_HICONSM_
    #undef GCL_HCURSOR_
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
HWND _txCanvas_CreateWindow (const SIZE* sizePtr)
    {
$8  if (_TX_ARGUMENT_FAILED (sizePtr)) return NULL;
 
$   bool centered = false;
    if (sizePtr->cx < 0 && sizePtr->cy < 0) {$ centered = true; }
 
$   SIZE screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$   RECT rect   = { 0, 0, abs (sizePtr->cx), abs (sizePtr->cy) }; AdjustWindowRect (&rect, _txWindowStyle, false);
$   SIZE size   = { rect.right - rect.left, rect.bottom - rect.top };
 
$   const char* wndClass = txRegisterClass ("MAIN", _txCanvas_WndProc, CS_HREDRAW | CS_VREDRAW | CS_OWNDC, BLACK_BRUSH, 0);
$   if (!wndClass) return (HWND) NULL;
 
$   HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, wndClass, txGetModuleFileName (false), _txWindowStyle | WS_CLIPCHILDREN,
                               centered? screen.cx/2 - size.cx/2 : CW_USEDEFAULT,
                               centered? screen.cy/2 - size.cy/2 : CW_USEDEFAULT,
                               size.cx, size.cy, NULL, NULL, NULL, NULL);
$   if (!wnd || !txWindow())
        {$ return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx() failed"), (HWND) NULL; }
 
$   HMENU menu = GetSystemMenu (txWindow(), false);
    if (!menu) {$ return txWindow(); }
 
$   AppendMenu (menu, MF_SEPARATOR, 0, NULL)                       asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$   AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT,   "&About...")     asserted;
 
$   return txWindow();
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
const char* txRegisterClass (const char classId[], WNDPROC wndProc, unsigned style, int backBrush, int wndExtra)
    {
$8  assert (classId);
$   assert (wndProc);
 
$   static char name[_TX_BUFSIZE] = "";
$   _tx_snprintf_s (name, sizeof (name) - 1, "/*---[TXLib]-[%s]------------ "
                                             _TX_VERSION "  " __FILE__ "  WndClass %08lX "
                                             "-------------[%s]-[TXLib]---*/",
                                             classId, (unsigned long) GetTickCount(), classId);
$   WNDCLASS wc      = { sizeof (wc) };
 
$   wc.lpszClassName = name;
$   wc.lpfnWndProc   = wndProc;
$   wc.style         = style;
$   wc.cbWndExtra    = (wndExtra + 1) * (int) sizeof (long);
 
$   wc.hCursor       = LoadCursor (NULL, IDC_ARROW);
$   wc.hbrBackground = (HBRUSH) Win32::GetStockObject (backBrush);
 
$   ATOM atom = RegisterClass (&wc);
    if (!atom) {$ TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed", name); return 0; }
 
$   return (const char*)(uintptr_t) atom;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline bool _txCanvas_OK()
    {
    return _txCanvas_ThreadId   &&
           _txCanvas_Window     &&
           _txCanvas_BackBuf[0] &&
           _txCanvas_BackBuf[1] &&
           _txCanvas_Pixels;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int _txCanvas_SetRefreshLock (int count)
    {
$8  int oldCount = _txCanvas_RefreshLock;
 
$   _txCanvas_RefreshLock = count;
 
$   HWND wnd = txWindow();
 
$   if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
        {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }
 
$   return oldCount;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
HICON _txCreateTXIcon (int size)
    {
$8  if (_TX_ARGUMENT_FAILED (size == 32 || size == 16)) return NULL;
 
$   const unsigned char image32 [32*32+1] =
        "00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
        "0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
        "0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
        "0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
        "0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
        "0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
        "0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
        "0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";
 
$   const unsigned char image16 [16*16+1] =
        "0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
        "0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";
 
$   const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
                                      0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };
 
$   const unsigned char* image = (size == 32)? image32 : image16;
 
$   POINT sz = { size, size };
$   HDC dcMask  = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$   HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);
 
$   for (int i = 0; i < size*size; i++)
        {
        assert (In (std::nomeow, image[i], '0', '9') ||
                In (std::nomeow, image[i], 'A', 'F'));
 
        Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
        }
 
$   ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask,  OBJ_BITMAP),
                                  (HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };
 
$   HICON icon = CreateIconIndirect (&info);
$   assert (icon);
 
$   _txBuffer_Delete (&dcMask)  asserted;
$   _txBuffer_Delete (&dcColor) asserted;
 
$   return icon;
    }
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Main window event handlers          (_txCanvas_On...)
//=================================================================================================================
 
LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
#if defined (_TX_ALLOW_TRACE)
 
    int inTX = _txLoc::Cur.inTX++;
 
    if (_txLoc::Cur.trace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__, "%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)",
                                     2 * (_txLoc::Cur.inTX - 1), "", wnd, msg, wpar, lpar);
    _txLoc::Cur.inTX = inTX;
 
#endif
 
$8  if (msg == WM_KEYDOWN && wpar == VK_F12 &&
        GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
        {
$       _txCanvas_OnCmdABOUT (wnd,      wpar);
$       return DefWindowProc (wnd, msg, wpar, lpar);
        }
 
    WNDPROC altWndProc = _txAltWndProc;  // Cache to prevent change from main thread
    if (altWndProc)
        {
$       LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$       if (res) return res;
        }
 
    static bool bkErased = false;
 
    switch (msg)
        {
        case WM_CREATE:         {$     _txCanvas_OnCREATE     (wnd);                return 0; }
 
        case WM_CLOSE:          {$ if (_txCanvas_OnCLOSE      (wnd))  break;   else return 0; }
        case WM_DESTROY:        {$     _txCanvas_OnDESTROY    (wnd);                return 0; }
 
        case WM_ERASEBKGND:     {$ if (!bkErased) { bkErased = true;  break; } else return 1; }
        case WM_SIZE:           {$                  bkErased = false; break;                  }
 
        case WM_PAINT:          {$     _txCanvas_OnPAINT      (wnd);                return 0; }
 
        case WM_TIMER:          {$     _txCanvas_OnTIMER      (wnd, wpar);          return 0; }
 
        case WM_KEYDOWN:        {$     _txCanvas_OnKEYDOWN    (wnd, wpar, lpar);    return 0; }
        case WM_CHAR:           {$     _txCanvas_OnCHAR       (wnd, wpar, lpar);    return 0; }
 
        case WM_LBUTTONUP:
        case WM_LBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MOUSEMOVE:      {$     _txCanvas_OnMOUSEMOVE  (wnd, wpar, lpar);    return 0; }
 
        case WM_MOUSELEAVE:     {$     _txCanvas_OnMOUSELEAVE (wnd);                return 0; }
 
        case _TX_WM_CREATEWND:  {$     _txCanvas_OnCREATEWND  (wnd, wpar, lpar);    return 0; }
        case _TX_WM_DESTROYWND: {$     _txCanvas_OnDESTROYWND (wnd, wpar, lpar);    return 0; }
 
        default: break;
        }
 
    if (msg == WM_SYSCOMMAND) switch (wpar)
        {
        case _TX_IDM_ABOUT:     {$       _txCanvas_OnCmdABOUT   (wnd, wpar);        return 0; }
        case _TX_IDM_CONSOLE:   {$       _txCanvas_OnCmdCONSOLE (wnd, wpar);        return 0; }
 
        default: break;
        }
 
$   return DefWindowProc (wnd, msg, wpar, lpar);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnCREATE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
 
$   _txCanvas_BackBuf[0] = _txBuffer_Create (wnd, NULL, NULL, &_txCanvas_Pixels); assert (_txCanvas_BackBuf[0]);
$   _txCanvas_BackBuf[1] = _txBuffer_Create (wnd, NULL, NULL, NULL);              assert (_txCanvas_BackBuf[1]);
 
$   if (!SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL)) _txCanvas_RefreshTimer = 0;
$   assert (_txCanvas_RefreshTimer);
 
$   _txCanvas_UserDCs = new ::std::vector <HDC>;
 
$   _txCanvas_Window = wnd;
 
$   txSetDefaults();
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnDESTROY (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
 
    // Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé
$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);

$   if (!_txCanvas_Window) return false;

    // Indicate that we are about to manually terminate

$   _txExit = true;

    // Lock GDI resources

$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");

    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû

$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
 
$   PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);
 
$   if (!_txCanvas_Window) return false;
 
    // Indicate that we are about to manually terminate
 
$   _txExit = true;
 
    // Lock GDI resources
 
$   bool locked = false;
$   _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$   if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");
 
    // Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû
$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);

$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }

$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;

    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì

$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
 
$   if (_txCanvas_UserDCs && !_txCanvas_UserDCs->empty())
        {
$       txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$       Sleep (_TX_TIMEOUT);
 
$       for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$       _txCanvas_UserDCs->clear();
        }
 
$   delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;
 
    // Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì
$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;

$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;

$   txUnlock();

    // Indicate that we are destroyed

$   _txCanvas_Window = NULL;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;

$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);

$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;

$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];

$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };

$   POINT dcSize = txGetExtent (dc1);

$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);

$       _txConsole_Draw (dc1);

$       txUnlock();
        }

    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(

$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }

$   EndPaint (wnd, &ps) asserted;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;

$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};

$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;

$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;

$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }

$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;

$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);

$   *(HWND*) create->hInstance = wnd;

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;

$   DestroyWindow ((HWND) lpar);

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;

$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;

$   bool visible = !!IsWindowVisible (console);

$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);

$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete

    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif

    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)

        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif

        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif

        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif

        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif

    #endif
    //}

$   static char text[_TX_BUFSIZE] = "";

$   _tx_snprintf_s (text, sizeof (text) - 1,

                    "Application:\n\n"

                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif

                    "\n" "%s", _txAppInfo());

$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);

    // And a bit of HTTP-code in C++ function:

    goto http;
    http://sizeof.livejournal.com

$   return true;

    #undef ABOUT_NAME_
    }

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//! @name    Ôóíêöèè êîíñîëüíîãî îêíà            (_txConsole...)
//=================================================================================================================
//! @{

HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();

$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }

$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;

$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   static bool done = false;
$   if (done) return console;

$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.

$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console

    // That's all, folks

$   done = true;
$   return console;
    }

//-----------------------------------------------------------------------------------------------------------------

int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows

$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }

    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).

$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }

    #ifndef __CYGWIN__

$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.

$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }

    #endif

    (void) wLocale;

$   return oldPage;
    }

//-----------------------------------------------------------------------------------------------------------------

void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
 
$   if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;
 
$   if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1])  asserted;
$   if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0])  asserted;
$   _txCanvas_Pixels = NULL;
 
$   txUnlock();
 
    // Indicate that we are destroyed
 
$   _txCanvas_Window = NULL;
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnCLOSE (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;
 
$   if (_txMain && _txRunning &&
        txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî?\n\n"
                      "Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
                      txGetModuleFileName (false), MB_YESNOCANCEL | MB_ICONSTOP) != IDYES) return false;
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
 
$   if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;
 
$   InvalidateRect (wnd, NULL, false) asserted;
$   UpdateWindow   (wnd)              asserted;
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnPAINT (HWND wnd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;
 
$   bool forceRedraw = GetAsyncKeyState (VK_MENU)  && GetAsyncKeyState (VK_CONTROL) &&
                       GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);
 
$   PAINTSTRUCT ps = {};
$   HDC wndDc = BeginPaint (wnd, &ps);
$   if (!wndDc) return false;
 
$   HDC dc0 = _txCanvas_BackBuf[0],
        dc1 = _txCanvas_BackBuf[1];
 
$   RECT r = {};
$   GetClientRect (wnd, &r) asserted;
$   POINT wndSize = { r.right - r.left, r.bottom - r.top };
 
$   POINT dcSize = txGetExtent (dc1);
 
$   if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
        txLock (false))
        {
$       Win32::BitBlt   (dc1, 0, 0, dcSize.x, dcSize.y, dc0, 0, 0, SRCCOPY);
 
$       _txConsole_Draw (dc1);
 
$       txUnlock();
        }
 
    // Magic 100500 value is used to completely block screen refresh.
    // Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
    // Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
    // themselves.
    // Yes guys, with all your software installed. :(
 
$   if (_txCanvas_RefreshLock != 100500)
        {
        if (_txSwapBuffers)
            {
$           _txSwapBuffers    (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        else if (dcSize.x == wndSize.x && dcSize.y == wndSize.y)
            {
$           Win32::BitBlt     (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0,                     SRCCOPY);
            }
        else
            {
$           Win32::SetStretchBltMode (wndDc, HALFTONE);
$           Win32::StretchBlt (wndDc, 0, 0, wndSize.x, wndSize.y, dc1, 0, 0, dcSize.x, dcSize.y, SRCCOPY);
            }
        }
 
$   EndPaint (wnd, &ps) asserted;
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
    {
$8  INPUT_RECORD evt = {};
 
$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char)  MapVirtualKey ((WORD) vk, 2);   // 2 == MAPVK_VK_TO_CHAR
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD)  (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD)  vk;
$   evt.Event.KeyEvent.dwControlKeyState = (DWORD) (info & (1 << 24))? ENHANCED_KEY : 0;
 
$   if (evt.Event.KeyEvent.uChar.AsciiChar) return false;  // Let TranslateMessage() and WM_CHAR do the job
 
$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);
 
$   return false;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
    {
$8  INPUT_RECORD evt = {};
 
$   evt.EventType                        = KEY_EVENT;
$   evt.Event.KeyEvent.bKeyDown          = true;
$   evt.Event.KeyEvent.wRepeatCount      = 1;
$   evt.Event.KeyEvent.uChar.AsciiChar   = (char) (ch);
$   evt.Event.KeyEvent.wVirtualScanCode  = (WORD) (info >> 16);
$   evt.Event.KeyEvent.wVirtualKeyCode   = (WORD) MapVirtualKey ((WORD) (info >> 16), 3);  // 3 == MAPVK_VSC_TO_VK_EX
$   evt.Event.KeyEvent.dwControlKeyState = 0;
 
$   DWORD written = 0;
$   WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
$   if (!_txCanvas_OK())           return false;
 
$   if (_txMousePos.x == -1 && _txMousePos.y == -1)
        {
$       TRACKMOUSEEVENT track = { sizeof (track), TME_HOVER | TME_LEAVE, wnd, HOVER_DEFAULT };
$       TrackMouseEvent (&track);
        }
 
$   _txMousePos.x   = LOWORD (coords);
$   _txMousePos.y   = HIWORD (coords);
$   _txMouseButtons = (unsigned) buttons;
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnMOUSELEAVE (HWND)
    {
$8  _txMousePos.x   = -1;
$   _txMousePos.y   = -1;
$   _txMouseButtons = 0;
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnCREATEWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;
 
$   const CREATESTRUCT* create = (CREATESTRUCT*) lpar;
 
$   HWND wnd = CreateWindowEx (create->dwExStyle, create->lpszClass, create->lpszName, create->style,
                               create->x, create->y, create->cx, create->cy,
                               create->hwndParent, create->hMenu, NULL, create->lpCreateParams);
 
$   *(HWND*) create->hInstance = wnd;
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnDESTROYWND (HWND, WPARAM, LPARAM lpar)
    {
$8  if (_TX_ARGUMENT_FAILED (lpar)) return false;
 
$   DestroyWindow ((HWND) lpar);
 
$   return false;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
    {
$8  if (_TX_ARGUMENT_FAILED (wnd)) return false;
 
$   HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;
 
$   bool visible = !!IsWindowVisible (console);
 
$   ShowWindow (console, visible? SW_HIDE : SW_SHOW);
 
$   visible = !!IsWindowVisible (console);
$   CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
    {
$8  //{ Overriding the missing names, if the set is uncomplete
 
    #if defined (__MODULE)
        #define ABOUT_NAME_    __MODULE
    #else
        #define ABOUT_NAME_    "TXLib"
    #endif
 
    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
 
        #ifndef __MODULE
        #define __MODULE       "TXLib"                           "\n"  "#define __MODULE to set the name.\n"
        #endif
 
        #ifndef __VERSION
        #define __VERSION      "(0.000000000)."                  "\n" "#define __VERSION to set the string value.\n"
        #endif
 
        #ifndef __DESCRIPTION
        #define __DESCRIPTION  "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
        #endif
 
        #ifndef __AUTHOR
        #define __AUTHOR       "(Íåïîíÿòíî êòî)."                "\n" "#define __AUTHOR to override this name."
        #endif
 
    #endif
    //}
 
$   static char text[_TX_BUFSIZE] = "";
 
$   _tx_snprintf_s (text, sizeof (text) - 1,
 
                    "Application:\n\n"
 
                    #if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
                        __MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
                    #else
                        "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
                        "#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
                    #endif
 
                    "\n" "%s", _txAppInfo());
 
$   txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);
 
    // And a bit of HTTP-code in C++ function:
 
    goto http;
    http://sizeof.livejournal.com
 
$   return true;
 
    #undef ABOUT_NAME_
    }
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Console-support functions           (_txConsole...)
//=================================================================================================================
 
HWND _txConsole_Attach()
    {
$1  HWND console = Win32::GetConsoleWindow();
 
$   if (!console)
        {
$       FreeConsole();
$       AllocConsole();
        }
 
$   console = Win32::GetConsoleWindow();
$   if (!console) return NULL;
 
$   txSetLocale();                                // Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows
 
$   static bool done = false;
$   if (done) return console;
 
$   _txConsole_SetUnicodeFont();                  // Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.
 
$   if (!_txIsConsoleSubsystem())
        {$ txReopenStdio(); }                     // Ïåðåîòêðûâàåì ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console
 
    // That's all, folks
 
$   done = true;
$   return console;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int txSetLocale (int codepage /*= _TX_CODEPAGE*/,
                 const char locale[] /*= _TX_LOCALE*/, const wchar_t wLocale[] /*= _TX_WLOCALE*/)
    {
$1  int oldPage = GetConsoleOutputCP();
 
    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows
 
$   if (codepage)
        {
$       SetConsoleCP       (codepage);
$       SetConsoleOutputCP (codepage);
        }
 
    // Óñòàíàâëèâàåì íóæíóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
    // ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ îïðåäåëåííûì
    // ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=NNNN -fexec-charset=NNNN, ãäå NNNN -
    // îáîçíà÷åíèå êîäîâîé ñòðàíèöû (íàïðèìåð, äëÿ ðóññêîãî ÿçûêà - CP1251).
 
$   if (locale)
        {
$       setlocale (LC_ALL,     locale);
$       setlocale (LC_NUMERIC, "C");              // Return to decimal point (3.14) instead of comma (3,14) in floating numbers
        }
 
    #ifndef __CYGWIN__
 
$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.
 
$   if (wLocale && !wine)
        {
$       _wsetlocale (LC_ALL,     wLocale);
$       _wsetlocale (LC_NUMERIC, L"C");           // L"C" (see above)
        }
 
    #endif
 
    (void) wLocale;
 
$   return oldPage;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void txReopenStdio()
    {
$1  // Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó
 
    #ifndef __CYGWIN__
 
$   *stdin  =                  *_fdopen (_open_osfhandle ((intptr_t) GetStdHandle (STD_INPUT_HANDLE),  _O_TEXT), "r");
$   fflush (stdout); *stdout = *_fdopen (_open_osfhandle ((intptr_t) GetStdHandle (STD_OUTPUT_HANDLE), _O_TEXT), "w");
$   fflush (stderr); *stderr = *_fdopen (_open_osfhandle ((intptr_t) GetStdHandle (STD_ERROR_HANDLE),  _O_TEXT), "w");
 
    #else
$                    *stdin  = *_fdopen (STDIN_FILENO,  "r");
$   fflush (stdout); *stdout = *_fdopen (STDOUT_FILENO, "w");
$   fflush (stderr); *stderr = *_fdopen (STDERR_FILENO, "w");
 
    #endif
 
$   setvbuf (stdin,  NULL, _IONBF, 0);
$   setvbuf (stdout, NULL, _IONBF, 0);
$   setvbuf (stderr, NULL, _IONBF, 0);
 
$   ::std::ios::sync_with_stdio();
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline bool _txConsole_OK()
    {
    return Win32::GetConsoleWindow() != NULL;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txConsole_Detach (bool activate)
    {
$1  HWND console = Win32::GetConsoleWindow();
$   if (!console) return false;
 
$   EnableWindow (console, true);
$   ShowWindow   (console, SW_SHOW);
 
$   if (activate)
        {
$       SetForegroundWindow (console);
$       BringWindowToTop    (console);
        }
 
$   return !!FreeConsole();
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txConsole_Draw (HDC dc)
    {
$8  if (_TX_HDC_FAILED (dc)) return false;
 
$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);
 
$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   BOOL ok = GetConsoleScreenBufferInfo (out, &con);
$   if (!ok) return false;
 
$   POINT size = { con.srWindow.Right  - con.srWindow.Left + 1,
                   con.srWindow.Bottom - con.srWindow.Top  + 1 };
 
$   SIZE fontSz = { 12, 16 };
$   Win32::GetTextExtentPoint32 (dc, "W", 1, &fontSz) asserted;
 
$   COLORREF pal [16] = { 0x000000, 0x800000, 0x008000, 0x808000, 0x000080, 0x800080, 0x008080, 0xC0C0C0,
                          0x808080, 0xFF0000, 0x00FF00, 0xFFFF00, 0x0000FF, 0xFF00FF, 0x00FFFF, 0xFFFFFF };
 
$   for (short y = 0; y < size.y; y++)
        {
        static char chr [_TX_BUFSIZE + 1] = "";  // [con.dwSize.X + 1]; maybe will be truncated
        static WORD atr [_TX_BUFSIZE + 1] = {}; // [con.dwSize.X + 1]; maybe will be truncated
        COORD coord = { (short) (con.srWindow.Left), (short) (y + con.srWindow.Top) };
        DWORD read  = 0;
 
        if (!ReadConsoleOutputCharacter (out, chr, sizearr (chr) - 1, coord, &read)) continue;
        if (!ReadConsoleOutputAttribute (out, atr, sizearr (atr) - 1, coord, &read)) continue;
 
        for (int x = 0, xEnd = size.x; x < size.x; x = xEnd)
            {
            Win32::SetTextColor (dc, pal [ atr[x]       & 0x0F]);
            Win32::SetBkColor   (dc, pal [(atr[x] >> 4) & 0x0F]);
            Win32::SetBkMode    (dc,      (atr[x]       & 0xF0)? OPAQUE : TRANSPARENT);
 
            for (xEnd = x+1; xEnd < size.x && atr[xEnd] == atr[x]; xEnd++) {;}
 
            Win32::TextOut (dc, ROUND (fontSz.cx * (x + con.srWindow.Left)),
                                ROUND (fontSz.cy *  y), chr + x, xEnd - x) asserted;
            }
        }
 
$   Win32::SetTextColor (dc, pal [ con.wAttributes       & 0x0F]);
$   Win32::SetBkColor   (dc, pal [(con.wAttributes >> 4) & 0x0F]);
$   Win32::SetBkMode    (dc, TRANSPARENT);
 
$   if (_txConsole_IsBlinking &&
        In (con.dwCursorPosition, con.srWindow) &&
        GetTickCount() % _txCursorBlinkInterval*2 > _txCursorBlinkInterval &&
        GetForegroundWindow() == txWindow())
        {
$       Win32::TextOut (dc, ROUND (fontSz.cx * (con.dwCursorPosition.X - con.srWindow.Left)),
                            ROUND (fontSz.cy * (con.dwCursorPosition.Y - con.srWindow.Top)) + 1,
                            "_", 1) asserted;
        }
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
//{          Welcome to the Duck Side! Together we will rule the Bathroom!
//-----------------------------------------------------------------------------------------------------------------
 
bool _txConsole_SetUnicodeFont()
    {
$   const bool wine = !!Win32::wine_get_version;  // Linux::Wine v1.2.2+ compatibility.
                                                  // Beer compatibility may be added in future versions...
$   if (wine)                                     // Ìèíçäðàâ ÐÔ ïðåäóïðåæäàåò: ÷ðåçìåðíîå óïîòðåáëåíèå wine
        {                                         // âðåäèò Âàøåìó çäîðîâüþ.
$       Win32::GetNumberOfConsoleFonts = NULL;
$       Win32::GetCurrentConsoleFont   = NULL;
$       Win32::SetConsoleFont          = NULL;
 
$       return false;
        }
 
    // Íà÷èíàÿ ñ Âèñòû âñå õîðîøî...
 
$1  if (Win32::GetCurrentConsoleFontEx && Win32::SetCurrentConsoleFontEx)
        {
$       HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);
 
$       Win32::CONSOLE_FONT_INFOEX info = { sizeof (info) };
$       if (!Win32::GetCurrentConsoleFontEx (out, false, &info)) return false;
 
$       info.FontFamily = 0x36;                                                    // Unicode fixed-pitch
$       if (!*info.FaceName) info.dwFontSize.Y = (SHORT) (info.dwFontSize.Y + 2);  // Terminal font is too small
 
$       if (wcsncmp (info.FaceName, L"Consolas", sizearr (info.FaceName)) != 0)    // Consolas is allowed too
            {$ wcsncpy_s (info.FaceName, sizearr (info.FaceName), L"Lucida Console", sizearr (info.FaceName)); }
 
$       return !!Win32::SetCurrentConsoleFontEx (out, false, &info);
        }
 
    // ...à äî ýòîãî âñå íå òàê ñëàäêî
 
$   const unsigned uniFont = 10;                  // The Internet and W2K sources know this magic number
$   const unsigned uniSize = 20;                  // Size of the font desired, should be > max # of Raster Fonts
$   bool ok = true;
 
    // Force Windows to use Unicode font by creating and run the console shortcut tuned to use that font.
 
$   HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);
 
$   unsigned fonts = _TX_CALL (Win32::GetNumberOfConsoleFonts, ());
$   if (fonts && fonts <= uniFont)
        {
$       HRESULT init = Win32::CoInitialize (NULL);
$       size_t sz = 0;
 
$       char link [MAX_PATH] = "";
$       getenv_s (&sz, link, sizeof (link) - 1, "TEMP");
$       strncat_s (link, sizeof (link), "\\~txLink.lnk", sizeof (link) - 1);
 
$       char comspec [MAX_PATH] = "";
$       getenv_s (&sz, comspec, sizeof (comspec), "COMSPEC");
 
$       (void) _unlink (link);
 
$       _txCreateShortcut (link, comspec, "/c exit", NULL, NULL, SW_SHOWMINNOACTIVE, NULL, 0, uniSize) asserted;
 
$       ok = (Win32::ShellExecuteA (NULL, NULL, link, NULL, NULL, SW_SHOWMINNOACTIVE) > (void*)32);  // Sic!
        if (ok) {$ _txWaitFor (FindWindow (NULL, "~txLink"), _TX_TIMEOUT); }
 
$       (void) _unlink (link);
 
$       if (init == S_OK) Win32::CoUninitialize();
        }
 
    // If Unicode font is not already set, do set it.
 
$   Win32::CONSOLE_FONT_INFO cur = {};
$   _TX_CALL (Win32::GetCurrentConsoleFont, (out, false, &cur));
 
$   ok &= (cur.nFont >= uniFont);
    if (!ok) {$ ok &= _TX_CALL (Win32::SetConsoleFont, (out, uniFont)); }
 
$   HWND console = Win32::GetConsoleWindow();
$   InvalidateRect (console, NULL, false);
$   UpdateWindow   (console);
 
$   return ok;
    }
 
//-----------------------------------------------------------------------------------------------------------------
//{          The assistants to the nightmare. You can use it freely to make your own nightmare sweet.
 
#define      _TX_TRY                { goto __tx_try; } __tx_try: { int __tx_error = S_OK; (void)__tx_error;
#define      _TX_CHECKED( cmd )     { if (FAILED (__tx_error = (cmd))) goto __tx_catch; }
#define      _TX_FAIL               { __tx_error = E_FAIL; goto __tx_catch; }
#define      _TX_RETRY              { __tx_error = S_OK;   goto __tx_try;   }
#define      _TX_OK                 ( SUCCEEDED (__tx_error) )
#define      _TX_CATCH              goto __tx_finally; __tx_catch:
#define      _TX_RETURN             goto __tx_finally;
#define      _TX_FINALLY            __tx_finally:
#define      _TX_ENDTRY             }
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
// Ìàëî íå ïîêàæåòñÿ
 
bool _txCreateShortcut (const char shortcutName[],
                        const char fileToLink[], const char args[] /*= NULL*/, const char workDir[] /*= NULL*/,
                        const char description[] /*= NULL*/, int cmdShow /*= SW_SHOWNORMAL*/, const char iconFile[] /*= NULL*/, int iconIndex /*= 0*/,
                        int fontSize /*= 0*/, COORD bufSize /*= ZERO (COORD)*/, COORD wndSize /*= ZERO (COORD)*/, COORD wndOrg /*=ZERO (COORD)*/)
    {
$1  if (_TX_ARGUMENT_FAILED (shortcutName && *shortcutName)) return false;
$   if (_TX_ARGUMENT_FAILED (fileToLink   && *fileToLink))   return false;
 
$   IShellLink* shellLink = NULL;
$   Win32::IShellLinkDataList* dataList = NULL;
$   IPersistFile* file = NULL;
 
$   HRESULT init = Win32::CoInitialize (NULL);
 
    _TX_TRY
        {
$       _TX_CHECKED (Win32::CoCreateInstance (CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, Win32::IID_IShellLink, (void**) &shellLink));
$       if (!shellLink) _TX_FAIL;
 
$       shellLink->SetPath (fileToLink);
$       shellLink->SetArguments (args);
$       shellLink->SetWorkingDirectory (workDir);
$       shellLink->SetDescription (description);
$       shellLink->SetShowCmd (cmdShow);
$       shellLink->SetIconLocation (iconFile, iconIndex);
 
$       _TX_CHECKED (shellLink->QueryInterface (Win32::IID_IShellLinkDataList, (void**) &dataList));
$       if (!dataList) _TX_FAIL;
 
$       Win32::NT_CONSOLE_PROPS props =
          {{sizeof (props), NT_CONSOLE_PROPS_SIG},
 
            FOREGROUND_LIGHTGRAY,                       // wFillAttribute
            FOREGROUND_MAGENTA | BACKGROUND_WHITE,      // wPopupFillAttribute
           {bufSize.X, bufSize.Y},                      // dwScreenBufferSize
           {wndSize.X, wndSize.Y},                      // dwWindowSize
           {wndOrg.X,  wndOrg.Y},                       // dwWindowOrigin
            0,                                          // nFont
            0,                                          // nInputBufferSize
           {0, (short) fontSize},                       // dwFontSize
            0x36, 400, L"Lucida Console",               // uFontFamily, uFontWeight, FaceName. We're dancing for this!
            15,                                         // uCursorSize
            0,  1, 1, 0,                                // bFullScreen, bQuickEdit, bInsertMode, bAutoPosition
            50, 4, 0,                                   // uHistoryBufferSize, uNumberOfHistoryBuffers, bHistoryNoDup
 
           {0x000000, 0x800000, 0x008000, 0x808000, 0x000080, 0x800080, 0x008080, 0xC0C0C0,  // Palette
            0x808080, 0xFF0000, 0x00FF00, 0xFFFF00, 0x0000FF, 0xFF00FF, 0x00FFFF, 0xFFFFFF}
            };
 
$       _TX_CHECKED (dataList->AddDataBlock (&props));
 
$       _TX_CHECKED (shellLink->QueryInterface (Win32::IID_IPersistFile, (void**) &file));
$       if (!file) _TX_FAIL;
 
$       wchar_t wName[MAX_PATH] = L"";
$       MultiByteToWideChar (_TX_CODEPAGE, 0, shortcutName, -1, wName, MAX_PATH) || ZeroMemory (wName, sizeof (wName));
 
$       _TX_CHECKED (file->Save (wName, true));
        }
 
$   _TX_CATCH
$   _TX_FINALLY
 
$   if (file)      file     ->Release();
$   if (dataList)  dataList ->Release();
$   if (shellLink) shellLink->Release();
 
$   if (init == S_OK) Win32::CoUninitialize();
 
$   return _TX_OK;
    _TX_ENDTRY
    }
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Memory DC functions                 (_txBuffer...)
//=================================================================================================================
 
HDC _txBuffer_Create (HWND wnd, const POINT* size /*= NULL*/, HBITMAP bitmap /*= NULL*/, RGBQUAD** pixels /*= NULL*/)
    {
$1  txAutoLock _lock;
 
$   HDC wndDC = GetDC (wnd);
$   if (!wndDC) return NULL;
 
$   POINT sz = { 1, 1 };
$   if (size) sz = *size;
 
$   if (!size && wnd)
        {
$       RECT r = {};
$       GetClientRect (wnd, &r) asserted;
 
$       sz.x = r.right  - r.left;
$       sz.y = r.bottom - r.top;
        }
 
$   if (bitmap)
        {
$       BITMAP bmap = {};
$       Win32::GetObject (bitmap, sizeof (bmap), &bmap) asserted;
 
$       sz.x = bmap.bmWidth;
$       sz.y = bmap.bmHeight;
        }
 
$   HDC dc = Win32::CreateCompatibleDC (wndDC);
$   if (!dc) TX_DEBUG_ERROR ("Cannot create buffer: CreateCompatibleDC() failed");
 
$   BITMAPINFO info = {{ sizeof (info), sz.x, sz.y, 1, WORD (sizeof (RGBQUAD) * 8), BI_RGB }};
 
$   HBITMAP bmap = bitmap? bitmap : Win32::CreateDIBSection (NULL, &info, DIB_RGB_COLORS, (void**) pixels, NULL, 0);
$   if (!bmap) TX_DEBUG_ERROR ("Cannot create buffer: CreateCompatibleBitmap() failed");
 
$   Win32::SelectObject (dc, bmap) asserted;
 
$   if (!bitmap) Win32::PatBlt (dc, 0, 0, sz.x, sz.y, BLACKNESS) asserted;
 
$   ReleaseDC (wnd, wndDC) asserted;
 
$   return dc;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txBuffer_Delete (HDC* dc)
    {
$1  if (_TX_ARGUMENT_FAILED (dc)) return false;
$   if (!*dc) return false;
 
$   if (_TX_HDC_FAILED (*dc)) return false;
 
$   if (!Win32::GetObjectType (Win32::GetCurrentObject (*dc, OBJ_BITMAP))) return false;
 
$   txAutoLock _lock;
 
$   _txBuffer_Select (Win32::GetStockObject (NULL_PEN),    *dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (NULL_BRUSH),  *dc) asserted;
$   _txBuffer_Select (Win32::GetStockObject (SYSTEM_FONT), *dc) asserted;
$   _txBuffer_Select (_txStockBitmap,                      *dc);
 
$   Win32::DeleteObject (Win32::GetCurrentObject (*dc, OBJ_BITMAP)) asserted;
 
$   Win32::DeleteDC (*dc) asserted;
 
$   *dc = NULL;
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txBuffer_Select (HGDIOBJ obj, HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED (obj)) return false;
$   if (_TX_HDC_FAILED      (dc))  return false;
 
$   if (!Win32::GetObjectType (obj)) TX_DEBUG_ERROR ("Invalid GDI object type");
 
$   txAutoLock _lock;
 
$   obj = Win32::SelectObject (dc, obj);
$   if (obj) Win32::DeleteObject (obj);
 
$   return obj != NULL;
    }
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Diagnostics
//=================================================================================================================
 
const char* _txError (const char file[] /*= NULL*/, int line /*= 0*/, const char func[] /*= NULL*/, unsigned color /*= 0*/,
                      const char msg [] /*= NULL*/, ...)
    {                                                                        //---/\---/\-------Ýòî ASCII KOT!--//
$1  va_list arg; va_start (arg, msg);                                        //  {  '-'  }                      //
$$  const char* what = _txProcessError (file, line, func, color, msg, arg);  //  {  0 0  }     Äîáàâü åãî ñåáå  //
    va_end (arg);                                                            //  --> V <--  â èñõîäíèê, è òåáå  //
                                                                             //   \ \|/ /      áóäåò, íàâåðíî,  //
    if (!(msg && msg[0] == '\a')) return what;                               //    \___/  ïðèÿòíî îòëàæèâàòüñÿ  //
                                                                             //---------------äîëãèìè íî÷àìè:)--//
//  vvvvvvvvvvvvvvvvvv
    DebugBreak();   //>>> Êîòèêè, âû â îòëàä÷èêå. Íå ïóãàéòåñü. Åñòü øàíñ ïîñìîòðåòü ïåðåìåííûå è ðàçîáðàòüñÿ.
//  ^^^^^^^^^^^^^^^^^^
 
    return what;    //>>> Óõîäèòå èç ôóíêöèè ïîøàãîâîé îòëàäêîé (F10/F11). Ñëåäèòå çà ñòåêîì âûçîâîâ (Alt+7).
    }
 
//-----------------------------------------------------------------------------------------------------------------
//{          General runtime check hooks
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnSignal (int sig /*= 0*/, int fpe /*= 0*/)
    {
$1  if (!sig && !fpe)
        {
$       signal (SIGSEGV, (void(*)(int))(uintptr_t)_txOnSignal) != SIG_ERR asserted;
$       signal (SIGFPE,  (void(*)(int))(uintptr_t)_txOnSignal) != SIG_ERR asserted;
$       signal (SIGABRT, (void(*)(int))(uintptr_t)_txOnSignal) != SIG_ERR asserted;
$       signal (SIGILL,  (void(*)(int))(uintptr_t)_txOnSignal) != SIG_ERR asserted;
$       signal (SIGTERM, (void(*)(int))(uintptr_t)_txOnSignal) != SIG_ERR asserted;
$       return;
        }
 
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %d) called\n", _TX_VERSION, __func__, sig, fpe);
 
    #define GET_DESCR_(str, code, descr)  case (code): {$ (str) = " " #code ": " descr; break; }
 
$   const char* sSig = "Íåèçâåñòíûé òèï ñèãíàëà;

$   switch (sig)
        {
        GET_DESCR_ (sSig, SIGSEGV, "Äîñòóï ïî íåâåðíîìó óêàçàòåëþ. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (sSig, SIGILL,  "Ïîïûòêà âûïîëíèòü íåäîïóñòèìóþ îïåðàöèþ. Ïðîâåðüòå óêàçàòåëè íà ôóíêöèè.")
        GET_DESCR_ (sSig, SIGABRT, "Àâàðèéíîå çàâåðøåíèå ïðîãðàììû, âûçâàíà ôóíêöèÿ abort().")
        GET_DESCR_ (sSig, SIGTERM, "Ïîëó÷åí ñèãíàë ïðèíóäèòåëüíîãî çàâåðøåíèÿ ïðîãðàììû.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si";
 
$   switch (sig)
        {
        GET_DESCR_ (sSig, SIGSEGV, "Äîñòóï ïî íåâåðíîìó óêàçàòåëþ. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (sSig, SIGILL,  "Ïîïûòêàâûïîëíèòü íåäîïóñòèìóþ îïåðàöèþ. Ïðîâåðüòå óêàçàòåëè íà ôóíêöèè.")
        GET_DESCR_ (sSig, SIGABRT, "Àâàðèéíîå çàâåðøåíèå ïðîãðàììû, âûçâàíà ôóíêöèÿ abort().")
        GET_DESCR_ (sSig, SIGTERM, "Ïîëó÷åí ñèãíàë ïðèíóäèòåëüíîãî çàâåðøåíèÿ ïðîãðàììû.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si âûïîëíèòüíåäîïóñòèìóþ îïåðàöèþ. Ïðîâåðüòå óêàçàòåëè íà ôóíêöèè.")
        GET_DESCR_ (sSig, SIGABRT, "Àâàðèéíîå çàâåðøåíèå ïðîãðàììû, âûçâàíà ôóíêöèÿ abort().")
        GET_DESCR_ (sSig, SIGTERM, "Ïîëó÷åí ñèãíàë ïðèíóäèòåëüíîãî çàâåðøåíèÿ ïðîãðàììû.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si íåäîïóñòèìóþ îïåðàöèþ. Ïðîâåðüòåóêàçàòåëè íà ôóíêöèè.")
        GET_DESCR_ (sSig, SIGABRT, "Àâàðèéíîå çàâåðøåíèå ïðîãðàììû, âûçâàíà ôóíêöèÿ abort().")
        GET_DESCR_ (sSig, SIGTERM, "Ïîëó÷åí ñèãíàë ïðèíóäèòåëüíîãî çàâåðøåíèÿ ïðîãðàììû.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si óêàçàòåëèíà ôóíêöèè.")
        GET_DESCR_ (sSig, SIGABRT, "Àâàðèéíîå çàâåðøåíèå ïðîãðàììû, âûçâàíà ôóíêöèÿ abort().")
        GET_DESCR_ (sSig, SIGTERM, "Ïîëó÷åí ñèãíàë ïðèíóäèòåëüíîãî çàâåðøåíèÿ ïðîãðàììû.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si íà ôóíêöèè")
        GET_DESCR_ (sSig, SIGABRT, "Àâàðèéíîå çàâåðøåíèå ïðîãðàììû, âûçâàíà ôóíêöèÿ abort().")
        GET_DESCR_ (sSig, SIGTERM, "Ïîëó÷åí ñèãíàë ïðèíóäèòåëüíîãî çàâåðøåíèÿ ïðîãðàììû.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si.")
        GET_DESCR_ (sSig, SIGABRT, "Àâàðèéíîåçàâåðøåíèå ïðîãðàììû, âûçâàíà ôóíêöèÿ abort().")
        GET_DESCR_ (sSig, SIGTERM, "Ïîëó÷åí ñèãíàë ïðèíóäèòåëüíîãî çàâåðøåíèÿ ïðîãðàììû.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si çàâåðøåíèå ïðîãðàììû âûçâàíà ôóíêöèÿ abort().")
        GET_DESCR_ (sSig, SIGTERM, "Ïîëó÷åí ñèãíàë ïðèíóäèòåëüíîãî çàâåðøåíèÿ ïðîãðàììû.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si, âûçâàíàôóíêöèÿ abort().")
        GET_DESCR_ (sSig, SIGTERM, "Ïîëó÷åí ñèãíàë ïðèíóäèòåëüíîãî çàâåðøåíèÿ ïðîãðàììû.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ôóíêöèÿ abort().")
        GET_DESCR_ (sSig, SIGTERM, "Ïîëó÷åíñèãíàë ïðèíóäèòåëüíîãî çàâåðøåíèÿ ïðîãðàììû.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñèãíàë ïðèíóäèòåëüíîãîçàâåðøåíèÿ ïðîãðàììû.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si çàâåðøåíèÿ ïðîãðàììû")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si.")
        GET_DESCR_ (sSig, SIGFPE,  "Ãðóáàÿ îøèáêà ââû÷èñëåíèÿõ.")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si âû÷èñëåíèÿõ")
        default:   break;
        }

$   const char* sFPE = "";

    #if defined (_MSC_VER)

    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx

$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèå íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si.")
        default:   break;
        }
 
$   const char* sFPE = "";
 
    #if defined (_MSC_VER)
 
    // MSVC provides the FPE code as a MS extension.
    // See: https://msdn.microsoft.com/ru-ru/library/xdkz3x12.aspx
 
$   if (sig == SIGFPE) switch (fpe)
        {
        GET_DESCR_ (sFPE, _FPE_INVALID,        "Ðåçóëüòàò íåâåðåí.")
        GET_DESCR_ (sFPE, _FPE_DENORMAL,       "Äåíîðìàëèçàöèÿ.")
        GET_DESCR_ (sFPE, _FPE_ZERODIVIDE,     "Äåëåíèåíà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàò ñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si íà íîëü.")
        GET_DESCR_ (sFPE, _FPE_OVERFLOW,       "Ðåçóëüòàòñëèøêîì áîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñëèøêîìáîëüøîé.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si áîëüøîé")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si.")
        GET_DESCR_ (sFPE, _FPE_UNDERFLOW,      "Ðåçóëüòàòñëèøêîì ìàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñëèøêîììàëåíüêèé.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ìàëåíüêèé")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàò íåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si.")
        GET_DESCR_ (sFPE, _FPE_INEXACT,        "Ðåçóëüòàòíåòî÷åí.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si íåòî÷åí")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si.")
        GET_DESCR_ (sFPE, _FPE_UNEMULATED,     "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ.")
        GET_DESCR_ (sFPE, _FPE_SQRTNEG,        "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si.")
        GET_DESCR_ (sFPE, _FPE_STACKOVERFLOW,  "Ïåðåïîëíåíèå ñòåêàñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñîïðîöåññîðà.")
        GET_DESCR_ (sFPE, _FPE_STACKUNDERFLOW, "Âñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñòåêåñîïðîöåññîðà íå õâàòàåò äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñîïðîöåññîðà íå õâàòàåòäàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûé âûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si äàííûõ.")
        GET_DESCR_ (sFPE, _FPE_EXPLICITGEN,    "ßâíûéâûçîâ èñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si âûçîâèñêëþ÷åíèÿ.")
        default:   break;
        }

    #else
$   fpe = 0;
    #endif

    #undef GET_DESCR_

$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);

$   Win32::_fpreset();

$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc

$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }

$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);

$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }

$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }

//-----------------------------------------------------------------------------------------------------------------

int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);

$1  assert (exc);

    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";

    #if !defined (__CYGWIN__)

    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }

$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si èñêëþ÷åíèÿ.")
        default:   break;
        }
 
    #else
$   fpe = 0;
    #endif
 
    #undef GET_DESCR_
 
$   signal (sig, (void(*)(int))(uintptr_t)_txOnSignal);
 
$   Win32::_fpreset();
 
$   _TX_UNEXPECTED ("\a\t"
                    "signal (%d, 0x%02X):%s%s "
                    "%s%s"
                    "Ñ ïîìîùüþ ôóíêöèè signal() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    sig, (unsigned) fpe, sSig, sFPE,
                    ((_txDumpSE[1] == '\n')? "" : "\n\n"), _txDumpSE + 1);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnTerminate()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
 
    // From: http://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/vterminate.cc
 
$1  static int terminating = 0;
    if (terminating++) {$ _TX_UNEXPECTED ("\a" "std::terminate() âûçâàíà ðåêóðñèâíî."); return; }
 
$   if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }
 
$   _TX_UNEXPECTED ("\t\a"
                    "std::terminate(): Íåïåðåõâà÷åííîå èñêëþ÷åíèå â ôóíêöèè main() èëè â äåñòðóêòîðå, "
                    "èëè äðóãàÿ ôàòàëüíàÿ îøèáêà C++. "
                    "%s"
                    "Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ïðîâåðÿéòå âûçîâû âèðòóàëüíûõ ôóíêöèé, "
                    "ðàçáèðàéòåñü, â ÷åì äåëî.\n\n"
                    "Ñ ïîìîùüþ std::set_terminate() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó." + !*_txDumpSE,
                    _txDumpSE + 1);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnUnexpected()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
 
$1  if (!*_txDumpSE)
        {$ _txDumpExceptionCPP (_txDumpSE + 1, sizeof (_txDumpSE) - 2); }
 
$   _TX_UNEXPECTED ("std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå.\n\n"
                    "Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). Åñëè âû (çðÿ) èñïîëüçóåòå "
                    "ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà."
                    "%s"
                    "Ñ ïîìîùüþ catch (...) â main() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    _txDumpSE + 1);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int _txOnMatherr (_exception* exc)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, exc);
 
$1  assert (exc);
 
    const char* sType = "Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";
 
    #if !defined (__CYGWIN__)
 
    #define GET_DESCR_(code, descr)  case (code): {$ sType = "(" #code "): " descr; break; }
 
$   switch (exc->type)
        {
        GET_DESCR_ (_DOMAIN,    "Íàðóøåíèå îáëàñòè îïðåäåëåíèÿ");
        GET_DESCR_ (_SING,      "Ñèíãóëÿðíîñòü àðãóìåíòà);
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si");
        GET_DESCR_ (_PLOSS,     "×àñòè÷íàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_TLOSS,     "Ïîëíàÿ ïîòåðÿ çíà÷èìîñòè");
        GET_DESCR_ (_OVERFLOW,  "Ðåçóëüòàò ñëèøêîì áîëüøîé);
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé");
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si");
        GET_DESCR_ (_UNDERFLOW, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé);
        default:   break;
        }

    #undef GET_DESCR_

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else

$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);

    #endif

    return 0;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);

$1  if (code)
        {$ errno = code; }

$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

//-----------------------------------------------------------------------------------------------------------------

int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);

$   throw std::bad_alloc();
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }

//-----------------------------------------------------------------------------------------------------------------

void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);

$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);

    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";

$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);

$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_CLANG_VER) && !defined (_MSC_VER)

void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);

$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

#pragma runtime_checks ("", off)

int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);

$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);

$   assert (format);

    // Disable all RTC failures

$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}

$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);

$   char text [_TX_BUFSIZE] = "";

$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);

$   const char* sType = "type";

$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }

$   const char* sError = _RTC_GetErrDesc (error);

$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);

    // The code below will be never executed until the error above will stay fatal:

    // Restore the RTC error types

    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));

    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif

$   InterlockedExchange (&running, 0);
$   return 1;
    }

#pragma runtime_checks ("", restore)

//-----------------------------------------------------------------------------------------------------------------

int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)

    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;

    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif

    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }

    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";

    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }

    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }

    #undef  GET_DESCR_

    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);

    recursive--;

    #else

    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);

    #endif

    return true;
    }

//-----------------------------------------------------------------------------------------------------------------

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;

    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");

    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;

            ret = _txPrevUEFilter (exc);

            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();

            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }

    _txLoc::Cur.inTX = inTX;
    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;

    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }

//-----------------------------------------------------------------------------------------------------------------

long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }

    assert (exc->ExceptionRecord);

    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');

    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;

    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;

    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;

    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);

$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }

    tx_fpreset();

    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif

$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));

$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();

$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);

$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);

$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;

$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif

$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);

$           prevCode = code;
$           prevAddr = addr;
            }

$       SetLastError (err);
        }

$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif

$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }

$   return EXCEPTION_CONTINUE_SEARCH;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);

$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;

$   char* s = what;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)

$   const char* sCode  = NULL;
$   const char* sDescr = NULL;

    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }

$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîä çà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si");
        default:   break;
        }
 
    #undef GET_DESCR_
 
$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà %d %s â ôóíêöèè %s (%lg, [%lg]). Îíà âåðíåò çíà÷åíèå %lg.\n\n"
                    "Ñ ïîìîùüþ __setusermatherr() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                    exc->type, sType, exc->name, exc->arg1, exc->arg2, exc->retval);
    #else
 
$   _TX_UNEXPECTED ("_matherr(): Ìàòåìàòè÷åñêàÿ îøèáêà: %s.", sType);
 
    #endif
 
    return 0;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnNewHandlerAnsi()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$1
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ std::set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.");
 
$   throw std::bad_alloc();
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnSecurityErrorAnsi (const char* msg, void* ptr, int code)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%s, 0x%p, %d) called\n", _TX_VERSION, __func__, msg, ptr, code);
 
$1  if (code)
        {$ errno = code; }
 
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d: %s â %.20s (0x%p). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ std::set_constraint_handler_s() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïîñòàðàòüñÿ íå âûõîäèòü çà ãðàíèöû ìàññèâîâ.",
                    code, msg, (char*) ptr, ptr);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline int tx_glGetError (int setError /*= INT_MIN*/)
    {
$1  return _txOGLError = (setError == INT_MIN)? Win32::glGetError() : setError;
    }
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{          MSC Runtime check hooks
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_MSC_VER)
 
//-----------------------------------------------------------------------------------------------------------------
 
int _txOnNewHandler (size_t size)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (0x%p) called\n", _TX_VERSION, __func__, (void*)(uintptr_t) size);
$5
$   _TX_UNEXPECTED ("operator new: Îøèáêà âûäåëåíèÿ %llu áàéò ïàìÿòè.\n\n"
                    "Ñ ïîìîùüþ _set_new_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ãäå-íèáóäü íàéòè íåäîñòàþùóþ ïàìÿòü.", (unsigned long long) size);
 
$   throw std::bad_alloc();
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnSecurityError (int code, void* addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, 0x%p) called\n", _TX_VERSION, __func__, code, addr);
$5
$   _TX_UNEXPECTED ("\a"
                    "Îøèáêà ïåðåïîëíåíèÿ áóôåðà %d (_SECERR_BUFFER_OVERRUN). Ñòàâüòå àññåðòû!\n\n"
                    "Ñ ïîìîùüþ _set_security_error_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è áîëåå òîðæåñòâåííî çàâåðøèòü ïðîãðàììó. Ñòàâüòå æå àññåðòû.", code);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnPureCall()
    {
    txOutputDebugPrintf ("%s - WARNING: %s() called\n", _TX_VERSION, __func__);
$5
$   _TX_UNEXPECTED ("\a"
                    "Âûçâàíà ÷èñòî âèðòóàëüíàÿ ôóíêöèÿ. Òàêîå áûâàåò, íàïðèìåð, â êîíñòðóêòîðàõ "
                    "èëè äåñòðóêòîðàõ áàçîâûõ êëàññîâ - íå âûçûâàéòå òàì òàêèõ ôóíêöèé.\n\n"
                    "Ñ ïîìîùüþ _set_purecall_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó "
                    "è ïðîâåðèòü ñâîå çíàíèå Ñ++ :)");
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txOnInvalidParam (const wchar_t* wExpr, const wchar_t* wFunc, const wchar_t* wFile, unsigned int line, uintptr_t addr)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%S, %S, %S, %d, 0x%p) called\n", _TX_VERSION, __func__, wExpr, wFunc, wFile, line, addr);
 
$5  assert (wExpr);
    assert (wFunc);
    assert (wFile);
 
    char expr [_TX_BUFSIZE/2] = "[Unknowm expr]",
         func [_TX_BUFSIZE/2] = "[Unknowm func]",
         file [MAX_PATH]      = "[Unknowm file]";
 
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wExpr, -1, expr, sizeof (expr) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFunc, -1, func, sizeof (func) - 1, NULL, NULL);
$   WideCharToMultiByte (_TX_CODEPAGE, 0, wFile, -1, file, sizeof (file) - 1, NULL, NULL);
 
$$  _txError (file, (int) line, func, 0, "\a"
              "Â ôóíêöèþ %s ïåðåäàí íåâåðíûé ïàðàìåòð: íåâåðíî, ÷òî %s. Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ _set_invalid_parameter_handler() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", func, expr);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_CLANG_VER) && !defined (_MSC_VER)
 
void _txLibCppDebugFunction (std::__libcpp_debug_info const& info)
    {
$5  assert (&info);
 
$$  _txError (info.__file_, info.__line_, NULL, 0, "\a"
              "Îêàçàëîñü íåâåðíî, ÷òî %s (%s). Íå íàäî òàê.\n\n"
              "Ñ ïîìîùüþ std::__libcpp_debug_function âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.", info.__pred_, info.__msg_);
    }
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
#pragma runtime_checks ("", off)
 
int _txOnRTCFailure (int type, const char* file, int line, const char* module, const char* format, ...)
    {
    txOutputDebugPrintf ("%s - WARNING: %s (%d, %s, %d, %s, %s) called\n", _TX_VERSION, __func__, type, file, line, module, format);
 
$5  static long running = 0;
$   while (InterlockedExchange (&running, 1)) Sleep (0);
 
$   assert (format);
 
    // Disable all RTC failures
 
$   int nErrors = _RTC_NumErrors();
$   int* errors = NULL;
$   try { errors = (int*) _alloca (nErrors * sizeof (*errors)); } catch (...) {;}
 
$   int err = 0;
$   for (int i = 0; i < nErrors; i++) *(errors? &errors[i] : &err) = _RTC_SetErrorType ((_RTC_ErrorNumber) i, _RTC_ERRTYPE_IGNORE);
 
$   char text [_TX_BUFSIZE] = "";
 
$   va_list arg; va_start (arg, format);
$   _tx_vsnprintf_s (text, sizeof (text) - 1, format, arg);                  // Get message from the vararg list
$   auto error = (_RTC_ErrorNumber) va_arg (arg, int /*_RTC_ErrorNumber*/);  // Get the RTC error number
$   va_end (arg);
 
$   const char* sType = "type";
 
$   switch (type)
       {
       case _CRT_ERROR:  $ sType = "îøèáêà";            break;
       case _CRT_ASSERT: $ sType = "ëîãè÷åñêàÿ îøèáêà"; break;
       case _CRT_WARN:   $ sType = "âîçìîæíàÿ îøèáêà";  break;
       default:          $                              break;
       }
 
$   const char* sError = _RTC_GetErrDesc (error);
 
$$  _txError (file, line, NULL, 0, "\a"
              "Ñáîé ïðîâåðêè âûïîëíåíèÿ ìàøèííîãî êîäà: %s %d (%s): %s â ìîäóëå %s.", sType, error, sError, text, module);
 
    // The code below will be never executed until the error above will stay fatal:
 
    // Restore the RTC error types
 
    #if defined (_MSC_VER)
    #pragma warning (disable: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif
 
$   for (int i = 0; i < nErrors; i++) _RTC_SetErrorType ((_RTC_ErrorNumber) i, (errors? errors[i] : _CRT_ERROR));
 
    #if defined (_MSC_VER)
    #pragma warning (default: 6385)  // Reading invalid data from 'errors': the readable size is 'n' bytes, but 'm' bytes may be read.
    #endif
 
$   InterlockedExchange (&running, 0);
$   return 1;
    }
 
#pragma runtime_checks ("", restore)
 
//-----------------------------------------------------------------------------------------------------------------
 
int _txOnAllocHook (int type, void* data, size_t size, int use, long request, const unsigned char* file, int line)
    {
    #if (_TX_ALLOW_TRACE +0 >= 4)
 
    static _tx_thread int recursive = 0;
    if (recursive) return true;
    recursive++;
 
    #if (_TX_ALLOW_TRACE +0 <= 10)
    if (!size) return true;
    #endif
 
    #define GET_DESCR_(str, type)  case (type): { str = #type; break; }
 
    const char* sType = "Unknown type";
    const char* sUse  = "Unknown use";
 
    switch (_BLOCK_TYPE (type))
        {
        GET_DESCR_ (sType, _HOOK_ALLOC);
        GET_DESCR_ (sType, _HOOK_REALLOC);
        GET_DESCR_ (sType, _HOOK_FREE);
        default:   break;
        }
 
    switch (use)
        {
        GET_DESCR_ (sUse,  _NORMAL_BLOCK);
        GET_DESCR_ (sUse,  _CRT_BLOCK);
        GET_DESCR_ (sUse,  _CLIENT_BLOCK);
        GET_DESCR_ (sUse,  _FREE_BLOCK);
        GET_DESCR_ (sUse,  _IGNORE_BLOCK);
        default:   break;
        }
 
    #undef  GET_DESCR_
 
    _txTrace ((const char*) file, line, NULL, "%*s"
              "_txOnAllocHook (type = 0x%02X (%-*s), subtype =0x%X, data = 0x%p, size = 0x%p, use = 0x%02X (%-*s), request = %ld)",
              2 * _txLoc::Cur.inTX, "",
              type, 13, sType, _BLOCK_SUBTYPE (type), data, (void*) size, use, 13, sUse, request);
 
    recursive--;
 
    #else
 
    UNREFERENCED_PARAMETER (type);
    UNREFERENCED_PARAMETER (data);
    UNREFERENCED_PARAMETER (size);
    UNREFERENCED_PARAMETER (use);
    UNREFERENCED_PARAMETER (request);
    UNREFERENCED_PARAMETER (file);
    UNREFERENCED_PARAMETER (line);
 
    #endif
 
    return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
#endif
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{          SEH staff
//-----------------------------------------------------------------------------------------------------------------
 
long WINAPI _txVectoredExceptionHandler (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;
 
    long ret = _txOnExceptionSEH (exc, "_txVectoredExceptionHandler");
 
    _txLoc::Cur.inTX = inTX;
    return ret;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
long WINAPI _txUnhandledExceptionFilter (EXCEPTION_POINTERS* exc)
    {
    int inTX = _txLoc::Cur.inTX++;
 
    long ret = _txOnExceptionSEH (exc, "_txUnhandledExceptionFilter");
 
    if (_txPrevUEFilter)
        {
        if (_txSetJmp())
            {
            int inTX2 = _txLoc::Cur.inTX++;
 
            ret = _txPrevUEFilter (exc);
 
            _txLoc::Cur.inTX = inTX2;
            }
        else
            {
$6          _txClearJmp();
 
            _TX_UNEXPECTED ("\t\a" "%s"
                            "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.\n\n"
                            "Äîïîëíèòåëüíî: Ñáîé âûçîâà ñòàíäàðòíîãî îáðàáîò÷èêà íåïåðåõâà÷åíííûõ èñêëþ÷åíèé SEH." + !*_txDumpSE,
                            _txDumpSE + 1);
            }
        }
 
    _txLoc::Cur.inTX = inTX;
    return ret;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI _txOnSetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER filter)
    {
$6  _txPrevUEFilter = filter;
 
    return (LPTOP_LEVEL_EXCEPTION_FILTER) _txUnhandledExceptionFilter;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
long _txOnExceptionSEH (EXCEPTION_POINTERS* exc, const char func[])
    {
    assert (exc); if (!exc) {$ return EXCEPTION_CONTINUE_SEARCH; }
 
    assert (exc->ExceptionRecord);
 
    assert (func);
    assert (func[3] == 'V' || func[3] == 'U');
 
    bool  unhExc = (func[3] == 'U');
    DWORD code   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionCode    : 0;
    void* addr   = (exc && exc->ExceptionRecord)? exc->ExceptionRecord->ExceptionAddress : NULL;
 
    if (code == DBG_PRINTEXCEPTION_C                  ||
        code == DBG_PRINTEXCEPTION_WIDE_C             ||
        code == DBG_THREAD_NAME                       ||
       (code == RPC_S_SERVER_UNAVAILABLE  && !unhExc) ||
       (code == RPC_S_CALL_CANCELLED      && !unhExc) ||
       (code == EXCEPTION_BREAKPOINT && IsDebuggerPresent()))
        return EXCEPTION_CONTINUE_SEARCH;
 
    _txSENumber++;
    if (HIBYTE (HIWORD (code)) == 0xC0) _txSEFatalNumber++;
 
    OutputDebugString ("\n");
    txOutputDebugPrintf ("%s - WARNING: #%ld: %s (code 0x%08lX, addr 0x%p) called\n",
                         _TX_VERSION, _txSENumber, func, (unsigned long) code, addr);
 
$6  if (*(unsigned long long*) _txDumpExceptionObjJmp)
        {
$       longjmp (_txDumpExceptionObjJmp, 1);
        }
 
    tx_fpreset();
 
    #if defined (_MSC_VER)
    if (code == EXCEPTION_STACK_OVERFLOW) {$ _resetstkoflw(); }
    #endif
 
$   bool primaryException = !(func && exc) || !((unhExc && *_txDumpSE) || _TX_MSC__CXX_DETECT_RETHROW (exc->ExceptionRecord));
 
$   if (primaryException && exc)
        {
$       unsigned err = GetLastError();
 
$       const char* stackTrace = _txCaptureStackBackTrace (0, true, exc->ContextRecord);
 
$       _txDumpExceptionSEH (_txDumpSE,  (intptr_t) sizeof (_txDumpSE)  - 1, exc->ExceptionRecord, func);
$       _tx_snprintf_s      (_txTraceSE, (intptr_t) sizeof (_txTraceSE) - 1, "%s", stackTrace);
 
$       static _tx_thread DWORD prevCode = 0;
$       static _tx_thread void* prevAddr = NULL;
 
$       if (code != prevCode && addr != prevAddr &&
            !strstr (_txDumpSE, "Îáúåêò èñêëþ÷åíèÿ C++:"))
            {
            #if !defined (_TX_NO_MINIDUMP)
$           _txCreateMiniDump (exc);
            #endif
 
$           SetLastError (err);
$           _TX_UNEXPECTED ("\v\b\t" "%s", _txDumpSE + 1);
 
$           prevCode = code;
$           prevAddr = addr;
            }
 
$       SetLastError (err);
        }
 
$   if (_txDumpSE[0]     == '\a'                   ||
        _txSENumber      >= _TX_EXCEPTIONS_LIMIT+0 ||
        _txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {
        #if !defined (_TX_NO_MINIDUMP)
$       _txCreateMiniDump (exc);
        #endif
 
$       _TX_UNEXPECTED ("\a\t" "%s"
                        "Ñ ïîìîùüþ ôóíêöèè _set_se_translator() âû ìîæåòå ñàìè îáðàáîòàòü ýòó îøèáêó.",
                        _txDumpSE + 1);
        }
 
$   return EXCEPTION_CONTINUE_SEARCH;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
intptr_t _txDumpExceptionSEH (char what[], intptr_t size, const EXCEPTION_RECORD* exc, const char func[])
    {
$6  assert (what);
$   assert (size >= 0);
    assert (exc); if (!exc) {$ return 0; }
$   assert (func);
 
$   unsigned         code   = exc->ExceptionCode;
$   void*            addr   = exc->ExceptionAddress;
$   unsigned         params = exc->NumberParameters;
$   const ULONG_PTR* info   = exc->ExceptionInformation;
$   void*            object = (params >= 2)? (void*) info[1] : NULL;
 
$   char* s = what;
 
    #define PRINT_(...)  s += _tx_snprintf_s (s, size-2 - (s-what), ##__VA_ARGS__)
 
$   const char* sCode  = NULL;
$   const char* sDescr = NULL;
 
    #define GET_DESCR_(code, descr)  case ((unsigned long) (code)): {$ sCode = #code; sDescr = descr; break; }
 
$   switch (code)
        {
        GET_DESCR_ (EXCEPTION_ACCESS_VIOLATION,         " "  "Íàðóøåíèå äîñòóïà ê ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_ILLEGAL_INSTRUCTION,      " "  "Íåäîïóñòèìàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_PRIV_INSTRUCTION,         " "  "Ïðèâèëåãèðîâàííàÿ îïåðàöèÿ.")
        GET_DESCR_ (EXCEPTION_ARRAY_BOUNDS_EXCEEDED,    "\a" "Âûõîäçà ãðàíèöû ìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si çà ãðàíèöûìàññèâà. Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ìàññèâà Ñòàâüòå àññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si. Ñòàâüòåàññåðòû!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si àññåðòû")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êà îñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si!")
        GET_DESCR_ (EXCEPTION_BREAKPOINT,               "\a" "Äîñòèãíóòà òî÷êàîñòàíîâà. Óäà÷è â îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îñòàíîâà. Óäà÷èâ îòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si âîòëàäêå!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îòëàäêå")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèå âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si!")
        GET_DESCR_ (EXCEPTION_DATATYPE_MISALIGNMENT,    "\a" "Íàðóøåíèåâûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèë íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si âûðàâíèâàíèÿ äàííûõ.")
        GET_DESCR_ (EXCEPTION_INVALID_DISPOSITION,      "\a" "Îáðàáîò÷èê èñêëþ÷åíèÿ âîçâðàòèëíåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòü íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si íåâåðíîå çíà÷åíèå.")
        GET_DESCR_ (EXCEPTION_IN_PAGE_ERROR,            "\a" "Íåâîçìîæíî çàãðóçèòüíóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèå âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si íóæíóþ ñòðàíèöó ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_NONCONTINUABLE_EXCEPTION, "\a" "Ïðîäîëæåíèåâûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíà èíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si âûïîëíåíèÿ íåâîçìîæíî.")
        GET_DESCR_ (EXCEPTION_SINGLE_STEP,              "\a" "Âûïîëíåíàèíñòðóêöèÿ ìàøèííîãî êîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si èíñòðóêöèÿ ìàøèííîãîêîäà. Îäíà øòóêà.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si êîäà. Îäíà øòóêà")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þ-õó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si.")
        GET_DESCR_ (EXCEPTION_STACK_OVERFLOW,           "\a" "Þõó! Ïåðåïîëíåíèå ñòåêà!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si-õó! Ïåðåïîëíåíèå ñòåêà")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêà äîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si!")
        GET_DESCR_ (EXCEPTION_GUARD_PAGE,               "\a" "Ïîïûòêàäîñòóïà ê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si äîñòóïàê çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si êçàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëè óæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si çàùèùåííîé ñòðàíèöå ïàìÿòè.")
        GET_DESCR_ (EXCEPTION_INVALID_HANDLE,           "\a" "Íåâåðíûé èëèóæå çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si óæåçàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")

        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêà ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si çàêðûòûé äåñêðèïòîð.")
        GET_DESCR_ (STATUS_POSSIBLE_DEADLOCK,           "\a" "Âîçìîæíî, âçàèìíàÿ áëîêèðîâêà ðåñóðñîâ.")
 
        GET_DESCR_ (EXCEPTION_FLT_STACK_CHECK,          "\a" "Îøèáêà ñòåêàïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïðèîïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îïåðàöèè ñïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïëàâàþùåéòî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëà ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DENORMAL_OPERAND,     " "  "Äåíîðìàëèçàöèÿ ÷èñëàñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïëàâàþùåéòî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèå íà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_DIVIDE_BY_ZERO,       " "  "Äåëåíèåíà íîëü ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si íà íîëü ïðèîïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îïåðàöèè ñïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïëàâàþùåéòî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàò ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INEXACT_RESULT,       " "  "Íåòî÷íûé ðåçóëüòàòïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïðèîïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îïåðàöèè ñïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïëàâàþùåéòî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_INVALID_OPERATION,    " "  "Íåäîïóñòèìàÿ îïåðàöèÿ ñïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïëàâàþùåéòî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_OVERFLOW,             " "  "Ïåðåïîëíåíèå ïðèîïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îïåðàöèè ñïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïëàâàþùåéòî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðè îïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si òî÷êîé.")
        GET_DESCR_ (EXCEPTION_FLT_UNDERFLOW,            " "  "Ïîòåðÿ çíà÷èìîñòè ïðèîïåðàöèè ñ ïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îïåðàöèè ñïëàâàþùåé òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïëàâàþùåéòî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûå îøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si òî÷êîé.")
        GET_DESCR_ (STATUS_FLOAT_MULTIPLE_FAULTS,       " "  "Ìíîæåñòâåííûåîøèáêè ñ ïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îøèáêè ñïëàâàþùåé òî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïëàâàþùåéòî÷êîé.")

        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîå äåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si òî÷êîé.")
 
        GET_DESCR_ (EXCEPTION_INT_DIVIDE_BY_ZERO,       "\a" "Öåëî÷èñëåííîåäåëåíèå íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si äåëåíèåíà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðè öåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si íà íîëü.")
        GET_DESCR_ (EXCEPTION_INT_OVERFLOW,             "\a" "Ïåðåïîëíåíèå ïðèöåëî÷èñëåííîé îïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si öåëî÷èñëåííîéîïåðàöèè.")

        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäû èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îïåðàöèè.")
 
        GET_DESCR_ (EXCEPTION_CLR_FAILURE,              "\a" "Ñáîé ñðåäûèñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãî áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si èñïîëíåíèÿ (CLR).")
        GET_DESCR_ (STATUS_STACK_BUFFER_OVERRUN,        "\a" "Ïåðåïîëíåíèå ñòåêîâîãîáóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàç èç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si áóôåðà!")
        GET_DESCR_ (STATUS_ASSERTION_FAILURE,           "\a" "Ñðàáîòàë assert. Íà ýòîò ðàçèç ÿäðà.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si èç ÿäðà")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êà îñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si.")
        GET_DESCR_ (STATUS_WX86_BREAKPOINT,             "\a" "Òî÷êàîñòàíîâà ïîäñèñòåìû ýìóëÿöèè x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îñòàíîâà ïîäñèñòåìû ýìóëÿöèèx86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûé èíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si x86.")
        GET_DESCR_ (RPC_S_UNKNOWN_IF,                   "\a" "Íåèçâåñòíûéèíòåðôåéñ óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si èíòåðôåéñóäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîê ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si óäàëåííîãî âûçîâà ïðîöåäóð (RPC).")
        GET_DESCR_ (RPC_S_SERVER_UNAVAILABLE,           "\a" "Ñåðâåð óäàëåííîãî âûçîâà ïðîöåäóð (RPC) íåäîñòóïåí.")
        GET_DESCR_ (DBG_TERMINATE_THREAD,               "\a" "Îòëàä÷èê çàâåðøèë ïîòîêñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñîçíàíèÿ.")
        GET_DESCR_ (DBG_TERMINATE_PROCESS,              "\a" "Îòëàä÷èê çàâåðøèë ïðîöåññ")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si.")
        GET_DESCR_ (DBG_CONTROL_C,                      "\a" "Îòëàä÷èê ïîëó÷èëñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èë ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñèãíàë ïðåðûâàíèÿ Control+C.")
        GET_DESCR_ (DBG_CONTROL_BREAK,                  "\a" "Îòëàä÷èê ïîëó÷èëñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èë óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñèãíàë ïðåðûâàíèÿ Control+Break.")
        GET_DESCR_ (DBG_THREAD_NAME,                    " "  "Îòëàä÷èê ïîëó÷èëóêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si óêàçàíèå äàòü ïîòîêó èìÿ.")
        GET_DESCR_ (DBG_PRINTEXCEPTION_C,               " "  "Îòëàä÷èê âûâåëèñêëþ÷åíèå ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si èñêëþ÷åíèåïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåë èñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïî CTRL+C (OutputDebugStringA).")
        GET_DESCR_ (DBG_PRINTEXCEPTION_WIDE_C,          " "  "Îòëàä÷èê âûâåëèñêëþ÷åíèå ïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si èñêëþ÷åíèåïî CTRL+C (OutputDebugStringW).")

        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ïî CTRL+C (OutputDebugStringW).")
 
        GET_DESCR_ (EXCEPTION_CPP_MSC,                  " "  "Èñêëþ÷åíèåÑ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si Ñ+, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si++, âûçâàííîåîïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC,                  " "  "Èñêëþ÷åíèåÑ++, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si Ñ+, âûçâàííîå îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si++, âûçâàííîåîïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si îïåðàòîðîì throw.")
        GET_DESCR_ (EXCEPTION_CPP_GCC_UNWIND,           " "  "Èñêëþ÷åíèåÑ++, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si Ñ+, âûçâàííîå âî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si++, âûçâàííîåâî âðåìÿ ðàñêðóòêè ñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si âî âðåìÿ ðàñêðóòêèñòåêà (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñòåêà(rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèå Ñ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si (rethrow?).")
        GET_DESCR_ (EXCEPTION_CPP_GCC_FORCED,           " "  "Èñêëþ÷åíèåÑ++, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si Ñ+, âûçâàííîå íàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si++, âûçâàííîåíàðóøåíèåì ìàãèè.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si íàðóøåíèåì ìàãèè")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòî ñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si.")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_BUILDER,      "\a" "Ýòîñêîìïèëèëîñü ïîä Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ñêîìïèëèëîñü ïîäÁèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòî æå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si Áèëäåð? O_O")
        GET_DESCR_ (EXCEPTION_CPP_BORLAND_DELPHI,       "\a" "Ýòîæå Ñ++. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si æå Ñ+. Êàê ýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si++. Êàêýòî âûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si ýòîâûøëî?")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si âûøëî")

        default: $ break;
        }

    #undef GET_DESCR_

$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }

$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);

$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;

    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }

$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);

$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");

$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";

$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si?")
 
        default: $ break;
        }
 
    #undef GET_DESCR_
 
$   if (sDescr)
        {
$       PRINT_ ("%s\n\n" "#%ld: Èñêëþ÷åíèå %s", sDescr, _txSENumber, sCode);
        }
    else
        {
$       PRINT_ ("\a#%ld: ", _txSENumber);
$       s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                            GetModuleHandle ("NTDLL.DLL"), code, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                            s, (DWORD) (size - (s-what)), NULL) - 2;
$       PRINT_ ("\r\r");
        }
 
$   PRINT_ (" (0x%X) ïðè âûïîëíåíèè êîäà ïî àäðåñó", code);
$   PRINT_ ((addr? " 0x%p" : " NULL"), addr);
 
$   Win32::SYMBOL_INFO*     sym  = NULL;
$   Win32::IMAGEHLP_LINE64* line = NULL;
 
    if (addr) {$ _txSymGetFromAddr (addr, &sym, &line); }
 
$   if (sym  &&                   *sym->Name)      PRINT_ (" â ôóíêöèè %s()", sym->Name);
$   if (line && line->FileName && *line->FileName) PRINT_ (" â ôàéëå %s íà ñòðîêå %u", line->FileName, (unsigned) line->LineNumber);
 
$   if (code == EXCEPTION_ACCESS_VIOLATION ||
        code == EXCEPTION_IN_PAGE_ERROR)
        {
$       PRINT_ (". Ïîïûòêà ");
 
$       unsigned long op = 0xBADC0DE;
$       const char*  sOp = "(äåéñòâèå íå óêàçàíî)";
 
$       if (params >= 1)
            {
$           switch (op = (unsigned long) info[0])
                {
                case 0:  $ sOp = "ïðî÷åñòü äàííûå";          break;
                case 1:  $ sOp = "çàïèñàòü äàííûå";          break;
                case 8:  $ sOp = "èñïîëíèòü êîä;            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }

$       PRINT_ (sOp, op);

$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }

$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");

$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];

$               PRINT_ (" 0x%lX (", ntstatus);

$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }

$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));

$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));

$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));

        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }

$   PRINT_ (".");

$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }

$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }

$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);

$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }

$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }

$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }

    #undef PRINT_

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");

$   return s - what;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);

$   char* s = what;

$   switch (code)
        {
        #if defined (_GCC_VER)

        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file

$           const std::type_info* type   = NULL;
$           void*                 object = NULL;

$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;

$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;

        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc

            using namespace abi;

$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;

$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }

$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());

$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;

        #elif defined (_MSC_VER)

        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf

$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;

$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];

$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;

                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )

$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);

$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;

                    #undef  RVA_
                    }
                }

$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;

        case 0:  // Not called within SEH chain

            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.

$           break;

        #endif

        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }

$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");

$   return (s - what);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);

$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;

    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)

$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");

$   const char* mangledName = (type)? type->name() : NULL;

$   char* typeName = NULL;
$   int err = 1;

    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif

$   const char* name = (!err && typeName)? typeName : mangledName;

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }

$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }

    if (name) {$ PRINT_ (" %s", name); }

    #if defined (_GCC_VER)
$   free (typeName);
    #endif

$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }

            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())

            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }

$   _txClearJmp();

$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;

$       if (szObj >= 64) szObj = 64;

$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );

$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);

$       err = 0;
        }

$   if (err)
        {$ PRINT_ (" = ???"); }

$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);

    #undef PRINT_VAL_
    #undef PRINT_

$   return s - what;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------

const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";

    if (framesToSkip == -1) {$ return trace; }

$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);

$   memset (trace, 0, sizeof (trace));
$   char* s = trace;

    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)

$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];

$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;

        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }

$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }

        #if !defined (_TX_FULL_STACKTRACE)

$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }

        #endif

$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;

        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }

        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }

        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }

    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif

$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;

    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif

    #undef PRINT_

$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");

$   return trace;
    }

//-----------------------------------------------------------------------------------------------------------------

// Stack WALKING if the program is DEAD. Dead, Carl!

int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;

$   assert (capture);

$   int cpu = 0;

$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;

$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;

$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }

$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }

    #if defined (_WIN64)

$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;

$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }

$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;

$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }

    #else

        {
$       cpu = IMAGE_FILE_MACHINE_I386;

$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }

    #endif

$   assert (cpu);

    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();

$   HANDLE process = GetCurrentProcess();

$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;

        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.

        if (!_txSetJmp()) {$ break; }

#if   defined (_GCC_VER)

        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)

$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }

$       void* addr = (void*) frame.AddrPC.Offset;

        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame

$       assert (0 <= frames && frames < (int) szCapture);

$       capture[frames] = addr;
        }

$   _txClearJmp();

$   return frames;
    }

// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl

//-----------------------------------------------------------------------------------------------------------------

bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;

#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW

#elif defined (_MSC_VER)
    #define LIB_  Win32

#else
    #error _GCC_VER / _MSC_VER not defined
#endif

$   if (!process && addr)
        {
$       process = GetCurrentProcess();

$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;

$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }

$   static DWORD64 mod = 0;

$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));

$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));

$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);

$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }

$       *module = sMod;
        }

$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;

$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));

$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;

$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));

        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }

$       *symbol = sym;
        }

$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };

$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));

$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));

$       *line = &line64;
        }

$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));

$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);

$           *source = buf;
            }

        if (!*source || !**source) {$ *source = NULL; }
        }

$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));

$       process = NULL;
        }

$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }

$       if (!line || !line64.FileName) return false;

$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);

$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }

    #undef LIB_

$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _txReadSource (char buf[], intptr_t si";            break;
                default: $ sOp = "ñîâåðøèòü îïåðàöèþ 0x%lX"; break;
                }
            }
 
$       PRINT_ (sOp, op);
 
$       if (params >= 2) {$ PRINT_ ((object? " ïî àäðåñó 0x%p" : " ïî àäðåñó NULL"), object); }
        else             {$ PRINT_ (" (àäðåñ íå óêàçàí)"); }
 
$       if (code == EXCEPTION_IN_PAGE_ERROR)
            {
$           PRINT_ (", îøèáêà ââîäà-âûâîäà:");
 
$           if (params >= 3)
                {
$               unsigned long ntstatus = (unsigned long) info[2];
 
$               PRINT_ (" 0x%lX (", ntstatus);
 
$               s += FormatMessage (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    GetModuleHandle ("NTDLL.DLL"), ntstatus, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (size - (s-what)), NULL) - 2;
$               PRINT_ (")");
                }
            else
                {$ PRINT_ (" (íå óêàçàíà)"); }
            }
        }
 
$   HMODULE module = NULL;
$   _TX_CALL (Win32::GetModuleHandleEx, (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char*) addr, &module));
 
$   if (module)
        {
$       static char sModule [MAX_PATH] = "";
$       int ok = GetModuleFileName (module, sModule, sizeof (sModule));
 
$       char* ext = (ok? strrchr (sModule, '.') : NULL);
$       if (ext) _strlwr_s (ext, sizeof (sModule) - 1 - (ext - sModule));
 
        if (ok) {$ PRINT_ (" â ìîäóëå %s",  sModule); }
        else    {$ PRINT_ (" â ìîäóëå 0x%p", module); }
        }
 
$   PRINT_ (".");
 
$   if (_txSENumber >= _TX_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Äîïîëíèòåëüíî, ïðåâûøåí ëèìèò èñêëþ÷åíèé _TX_EXCEPTIONS_LIMIT (%d).",        _TX_EXCEPTIONS_LIMIT+0); }
 
$   if (_txSEFatalNumber >= _TX_FATAL_EXCEPTIONS_LIMIT+0)
        {$ PRINT_ (" Òàêæå ïðåâûøåí ëèìèò ôàòàëüíûõ èñêëþ÷åíèé _TX_FATAL_EXCEPTIONS_LIMIT (%d).", _TX_FATAL_EXCEPTIONS_LIMIT+0); }
 
$   PRINT_ (" Ñïàñèáî %s(), ÷òî ñîîáùèë. Ëþáëþ åãî <3", func);
 
$   if (exc->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        {$ PRINT_ ("\n\n" "Îé, âñ¸ (EXCEPTION_NONCONTINUABLE)."); }
 
$   if (exc->ExceptionRecord)
        {
$       PRINT_ ("\n\n" "Ïðè÷èíà:" "\n\n");
$       s += _txDumpExceptionSEH (s, size - (s-what), exc->ExceptionRecord, func);
        }
 
$   if (code == EXCEPTION_CPP_GCC        ||
        code == EXCEPTION_CPP_GCC_UNWIND ||
        code == EXCEPTION_CPP_GCC_FORCED ||
        code == EXCEPTION_CPP_MSC)
        {
$       s += _txDumpExceptionCPP (s,    size - (s-what), code, params, info);
        }
 
    #undef PRINT_
 
$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s-what), "\n\n");
 
$   return s - what;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
intptr_t _txDumpExceptionCPP (char what[], intptr_t size,
                              unsigned code /*= 0*/, unsigned params /*= 0*/, const ULONG_PTR info[] /*= NULL*/)
    {
$6  assert (what);
$   assert (size >= 0);
 
$   char* s = what;
 
$   switch (code)
        {
        #if defined (_GCC_VER)
 
        case EXCEPTION_CPP_GCC:
        case EXCEPTION_CPP_GCC_UNWIND:
        case EXCEPTION_CPP_GCC_FORCED:
            {
            // See: [1] http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_exception.cpp
            //      [2] http://github.com/gcc-mirror/gcc/blob/master/libgcc/unwind-seh.c, lines 51-55 and below
            //      [3] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_throw.cc, __cxa_throw, line 59 and below
            //      [4] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/unwind-cxx.h, __cxa_exception, line 58 and below
            //      and figure above near ABI::__cxa_exception definition in this file
 
$           const std::type_info* type   = NULL;
$           void*                 object = NULL;
 
$           if (params >= 1)
                {
$               _Unwind_Exception*    unwind_exception = (_Unwind_Exception*) info[0];
$               ABI::__cxa_exception* cxa_exception    = (ABI::__cxa_exception*) (unwind_exception + 1) - 1;
 
$               type   = cxa_exception->exceptionType;
$               object = cxa_exception + 1;
                }
 
$           s += _txDumpExceptionObj (s, size - (s-what), object, 0, type);
            }
$           break;
 
        case 0:  // Not called within SEH chain
            {
            // From: [1] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_type.cc
            //       [2] http://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/vterminate.cc
 
            using namespace abi;
 
$           ABI::__cxa_exception* cxa_exception = __cxa_get_globals() -> caughtExceptions;
 
$           if (cxa_exception && (cxa_exception->unwindHeader.exception_class & 1))  // Dependent exception, case B, see pic above
                {
$               cxa_exception = (((ABI::__cxa_exception*) (&cxa_exception->unwindHeader + 1) - 1) -> primaryException) - 1;
                }
 
$           if (cxa_exception)
                {
$               verify (cxa_exception->exceptionType == abi::__cxa_current_exception_type());
 
$               s += _txDumpExceptionObj (s, size, cxa_exception + 1, 0, cxa_exception->exceptionType);
                }
            }
$           break;
 
        #elif defined (_MSC_VER)
 
        case EXCEPTION_CPP_MSC:
            {
            // See [1] http://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
            //     [2] http://www.openrce.org/articles/full_view/21
            //     [3] http://www.openrce.org/articles/full_view/23
            //     [4] http://yurichev.com/mirrors/RE/Recon-2012-Skochinsky-Compiler-Internals.pdf
 
$           const std::type_info* type   = NULL;
$           void*                 object = (params >= 2)? (void*) info[1] : NULL;
$           size_t                szObj  = 0;
 
$           if (params >= 3 &&
               (info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER1 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER2 ||
                info[0] == EXCEPTION_CPP_MSC_EH_MAGIC_NUMBER3 ||
                info[0] == EXCEPTION_CPP_MSC_EH_PURE_MAGIC_NUMBER1))
                {
$               auto throwInfo = (const Win32::ThrowInfo*) info[2];
 
$               if (throwInfo && throwInfo->pCatchableTypeArray)
                    {
$                   HMODULE module = (params >= 4)? (HMODULE) info[3] : NULL;
 
                    #define RVA_(type, addr)  ( (type) ((uintptr_t) module + (uintptr_t) (addr)) )
 
$                   const Win32::CatchableTypeArray* cArray = RVA_(const Win32::CatchableTypeArray*, throwInfo->pCatchableTypeArray);
$                   const Win32::CatchableType*      cType  = RVA_(const Win32::CatchableType*,      cArray->arrayOfCatchableTypes[0]);
 
$                   type  = RVA_(const std::type_info*, cType->pType);
$                   szObj = cType->sizeOrOffset;
 
                    #undef  RVA_
                    }
                }
 
$           s += _txDumpExceptionObj (s, size - (s-what), object, szObj, type);
            }
            break;
 
        case 0:  // Not called within SEH chain
 
            // signal() handlers or unexpected()/terminate() are called after Vectored Exception in MSC:
            //
            // terminate() is called by __scrt_unhandled_exception_filter() in case of MSC exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\utility_desktop.cpp
            //
            // signal() handlers are called by _seh_filter_exe(), which is called by _mainCRTStartup() in case of exception.
            // See C:\Bin\Microsoft Visual Studio 14.0\VC\crt\src\vcruntime\mcrtexe.cpp
            // and C:\Bin\Windows Kits\10\Source\10.0.10240.0\ucrt\misc\exception_filter.cpp
            // and http://msdn.microsoft.com/en-us/library/ff730818.aspx.
            //
            // So _txDumpSE information should have been recorded during previous call. Now do nothing.
 
$           break;
 
        #endif
 
        default:
$           txOutputDebugPrintf ("ERROR: Wrong call to %s: Unknown exception code 0x%08X\n", __TX_FUNCTION__, code);
$           break;
        }
 
$   while (s > what && s[-1] == '\n') s--;
$   if (s > what) s += _tx_snprintf_s (s, size - (s - what), "\n\n");
 
$   return (s - what);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
intptr_t _txDumpExceptionObj (char what[], intptr_t size, void* object, size_t sizeObj, const std::type_info* type)
    {
$6  assert (what);
$   assert (size > 0);
 
$   static char*  s     = NULL; s     = what;
$   static size_t szObj = 0;    szObj = sizeObj;
 
    #define PRINT_(...)  s += _tx_snprintf_s (s, size - (s - what), ##__VA_ARGS__)
 
$   PRINT_ ("\n\n" "Îáúåêò èñêëþ÷åíèÿ C++:");
 
$   const char* mangledName = (type)? type->name() : NULL;
 
$   char* typeName = NULL;
$   int err = 1;
 
    #if defined (_GCC_VER)
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err);
    #endif
 
$   const char* name = (!err && typeName)? typeName : mangledName;
 
$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >")           == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >")                   == 0))
        {$ name = "std::string"; }
 
$   if (name &&
       (strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > *")         == 0 ||
        strcmp (name, "class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > * __ptr64") == 0 ||
        strcmp (name, "std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*")                  == 0))
        {$ name = "std::string*"; }
 
    if (name) {$ PRINT_ (" %s", name); }
 
    #if defined (_GCC_VER)
$   free (typeName);
    #endif
 
$   err = 0;
$   if (mangledName)
        {
        if (_txSetJmp())
            {
            #define PRINT_VAL_(fmt, typ, ...)                                                                            \
                else if (*type == typeid (      typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ       )) {$ PRINT_ (" = " #fmt, (* (typ* ) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ*      )) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (      typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); } \
                else if (*type == typeid (const typ* const)) {$ PRINT_ (" = " #fmt, (**(typ**) object) __VA_ARGS__); }
 
            if (false) ;
            PRINT_VAL_ ("%s", char*)  PRINT_VAL_ ('%c', unsigned char)   PRINT_VAL_ (%s,   bool, ? "true" : "false")
            PRINT_VAL_ ( %d,  int)    PRINT_VAL_ ( %u,  unsigned int)    PRINT_VAL_ (%g,   float)
            PRINT_VAL_ ( %hd, short)  PRINT_VAL_ ( %hu, unsigned short)  PRINT_VAL_ (%lg,  double)
            PRINT_VAL_ ( %ld, long)   PRINT_VAL_ ( %lu, unsigned long)   PRINT_VAL_ ('%c', char)
            PRINT_VAL_ ("%s", std::string, .c_str())
 
            else if (std::exception* e = dynamic_cast <std::exception*> ( (std::exception* ) object))
                {
$               PRINT_ (", what(): \"%s\"", e->what());
                }
            else
                {$ err = 1; }
            }
        else
            {$ err = 2; }
        }
 
$   _txClearJmp();
 
$   if (err && object && szObj)
        {
$       const unsigned char* buf = (const unsigned char*) object;
 
$       if (szObj >= 64) szObj = 64;
 
$       PRINT_ (", äàìï: [");
$       for (size_t i = 0; i < szObj; i++) PRINT_ ("%c", (isprint (buf[i]) && !iscntrl (buf[i]))? buf[i] : '.' );
 
$       PRINT_ ("]");
$       for (size_t i = 0; i < szObj; i++) PRINT_ (" %02X", buf[i]);
 
$       err = 0;
        }
 
$   if (err)
        {$ PRINT_ (" = ???"); }
 
$   PRINT_ ((object? "%såãî àäðåñ 0x%p." : "%såãî àäðåñ NULL."), ((typeName || mangledName)? ", " : ""), object);
 
    #undef PRINT_VAL_
    #undef PRINT_
 
$   return s - what;
    }
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{          Stack trace and debug info access
//-----------------------------------------------------------------------------------------------------------------
 
const char* _txCaptureStackBackTrace (int framesToSkip /*= 0*/, bool readSource /*= true*/,
                                      CONTEXT* context /*= NULL*/, HANDLE thread /*= GetCurrentThread()*/)
    {
$6  const int maxFrames = 62;  // MS says: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";
 
    if (framesToSkip == -1) {$ return trace; }
 
$   static void* capture [maxFrames] = {};
$   int frames = _txStackWalk (framesToSkip + !context, sizearr (capture), capture, NULL, context, thread);
 
$   memset (trace, 0, sizeof (trace));
$   char* s = trace;
 
    #define PRINT_(...)  s += _tx_snprintf_s (s, sizeof (trace) - 1 - 3 - (s-trace), ##__VA_ARGS__)
 
$   for (int i = 0, n = 0; i < frames; i++)
        {
$       void* addr = capture[i];
 
$       Win32::SYMBOL_INFO*     sym    = NULL;
$       Win32::IMAGEHLP_LINE64* line   = NULL;
$       const char*             module = NULL;
$       const char*             source = NULL;
$       bool                    inTX   = false;
 
        if (addr)                {$ inTX = _txSymGetFromAddr ((char*) addr - 1, &sym, &line, &module);          }
        if (readSource && !inTX) {$        _txSymGetFromAddr ((void*) 1,        NULL, NULL,  NULL, &source, 2); }
 
$       int nl = 0;
$       while (s > trace && s[-1] == '\n') { s--; nl++; }
 
        #if !defined (_TX_FULL_STACKTRACE)
 
$       if (! ((sym && *sym->Name) || (line && ((line->FileName && *line->FileName) || line->LineNumber))))
            {$ continue; }
 
        #endif
 
$       PRINT_ ("%s#%2d 0x%p", ((n)? ((source || nl)? "\n\n" : "\n") : ""), i, addr);
$       n++;
 
        if (addr ==                    0)          {$ PRINT_ (" [Íåâåðíûé ôðåéì]");        break; }
        if (addr == (void*)           -1)          {$ PRINT_ (" [Ñòðàííûé ôðåéì]");        break; }
        if (addr == (void*)(uintptr_t) 0xBAADF00D) {$ PRINT_ (" [Ìóñîð îò LocalAlloc()]"); break; }
 
        if (module)                                {$ PRINT_ (" in %s%s",     module, ((sym && *sym->Name)? ": " : "")); }
        if (sym  && *sym->Name)                    {$ PRINT_ ("%s()",         sym->Name);                                }
        if (line && line->FileName)                {$ PRINT_ (" at %s",       line->FileName);                           }
        if (line && line->LineNumber)              {$ PRINT_ (" (%d)",  (int) line->LineNumber);                         }
        if (source)                                {$ PRINT_ (":\n\n" "%s\n", source);                                   }
 
        if (sym && strcmp (sym->Name , "main") == 0) {$ break; }
        }
 
    #if defined (_MSC_VER)
    #pragma warning (disable: 28199)  // Using possibly uninitialized memory '*s'
    #endif
 
$   while (s > trace && s[-1] == '\n') s--;
$   *s = 0;
 
    #if defined (_MSC_VER)
    #pragma warning (default: 28199)  // Using possibly uninitialized memory '*s'
    #endif
 
    #undef PRINT_
 
$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");
 
$   return trace;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
// Stack WALKING if the program is DEAD. Dead, Carl!
 
int _txStackWalk (int framesToSkip, size_t szCapture, void* capture[], unsigned long* /*backTraceHash*/,
                  CONTEXT* context /*= NULL*/, HANDLE thread /* = GetCurrentThread()*/)
    {
$6  namespace MinGW = Win32::MinGW;
 
$   assert (capture);
 
$   int cpu = 0;
 
$   Win32::STACKFRAME64 frame = {};
$   frame.AddrPC.Mode = frame.AddrStack.Mode = frame.AddrFrame.Mode = Win32::AddrModeFlat;
 
$   CONTEXT ctx = {};
$   ctx.ContextFlags |= CONTEXT_FULL;
 
$   int isWow64 = 0;
$   if (Win32::IsWow64Process) Win32::IsWow64Process (GetCurrentProcess(), &isWow64);
    else {$ return -1; }
 
$   if (context)
        {
$       ctx = *context;
        }
    else
        {
$       assert    (Win32::RtlCaptureContext);
$       _TX_CALLv (Win32::RtlCaptureContext, (&ctx));
        }
 
    #if defined (_WIN64)
 
$   if (isWow64)
        {
$       Win32::WOW64_CONTEXT wow64ctx = {};
$       wow64ctx.ContextFlags |= WOW64_CONTEXT_FULL;
 
$       if (!_TX_CALL (Win32::Wow64GetThreadContext, (thread, &wow64ctx)))  // In WINE, after EXIT_PROCESS_DEBUG_EVENT
            {$ return 0; }
 
$       cpu = IMAGE_FILE_MACHINE_I386;
 
$       frame.AddrPC   .Offset = wow64ctx.Eip;
$       frame.AddrStack.Offset = wow64ctx.Esp;
$       frame.AddrFrame.Offset = wow64ctx.Ebp;
        }
    else
        {
$       cpu = IMAGE_FILE_MACHINE_AMD64;
 
$       frame.AddrPC   .Offset = ctx.Rip;
$       frame.AddrStack.Offset = ctx.Rbp;
$       frame.AddrFrame.Offset = ctx.Rsp;
        }
 
    #else
 
        {
$       cpu = IMAGE_FILE_MACHINE_I386;
 
$       frame.AddrPC   .Offset = ctx.Eip;
$       frame.AddrStack.Offset = ctx.Ebp;
$       frame.AddrFrame.Offset = ctx.Esp;
        }
 
    #endif
 
$   assert (cpu);
 
    if (_txSetJmp())
        {
$       _txSymGetFromAddr ((void*) 1);
        }
$   _txClearJmp();
 
$   HANDLE process = GetCurrentProcess();
 
$   int  frames = 0;
$   for (frames = -framesToSkip; frames < (int) szCapture; frames++)
        {
$       DWORD64 prev = frame.AddrStack.Offset;
 
        // ß çëîé è ñòðàøíûé ñåðûé walk. ß â ïîðîñÿòàõ çíàþ talk.
 
        if (!_txSetJmp()) {$ break; }
 
#if   defined (_GCC_VER)
 
        if (!_TX_CALL (MinGW::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            MinGW::SymFunctionTableAccess64, MinGW::SymGetModuleBase64, NULL))) {$ break; }
#elif defined (_MSC_VER)
 
$       if (!_TX_CALL (Win32::StackWalk64, (cpu, process, thread, &frame, &ctx, NULL,
                                            Win32::SymFunctionTableAccess64, Win32::SymGetModuleBase64, NULL))) {$ break; }
#else
        #error _GCC_VER / _MSC_VER not defined
#endif
        if (frames < 0) {$ continue; }
 
$       void* addr = (void*) frame.AddrPC.Offset;
 
        if (frame.AddrFrame.Offset == 0)   {$ addr =          0; }  // Bad frame
        if (frame.AddrStack.Offset < prev) {$ addr = (void*) -1; }  // Strange frame
 
$       assert (0 <= frames && frames < (int) szCapture);
 
$       capture[frames] = addr;
        }
 
$   _txClearJmp();
 
$   return frames;
    }
 
// Note that Rick and Carl are speaking near the C language block. "C block", Carl. See: http://knowyourmeme.com/memes/carl
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txSymGetFromAddr (void* addr, Win32::SYMBOL_INFO** symbol /*= NULL*/,
                        Win32::IMAGEHLP_LINE64** line /*= NULL*/, const char** module /*= NULL*/,
                        const char** source /*= NULL*/, int context /*= 2*/)
    {
$7  static HANDLE process = NULL;
 
#if   defined (_GCC_VER)
    #define LIB_  Win32::MinGW
 
#elif defined (_MSC_VER)
    #define LIB_  Win32
 
#else
    #error _GCC_VER / _MSC_VER not defined
#endif
 
$   if (!process && addr)
        {
$       process = GetCurrentProcess();
 
$       DWORD options = SYMOPT_UNDNAME | SYMOPT_LOAD_LINES | SYMOPT_LOAD_ANYTHING | SYMOPT_INCLUDE_32BIT_MODULES |
                        SYMOPT_DEFERRED_LOADS | SYMOPT_FAVOR_COMPRESSED | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_NO_PROMPTS;
 
$        _TX_CALL (LIB_::SymSetOptions, (options));
$        _TX_CALL (LIB_::SymInitialize, (process, NULL, true));
        }
 
$   static DWORD64 mod = 0;
 
$   if (module)
        {
$       static char sMod [MAX_PATH] = "";
$       memset (sMod, 0, sizeof (sMod));
 
$       mod = _TX_CALL (LIB_::SymGetModuleBase64, (process, (uintptr_t) addr));
 
$       GetModuleFileName ((HMODULE)(intptr_t) mod, sMod, MAX_PATH);
 
$       char* ext = strrchr (sMod, '.');
        if (ext) {$ _strlwr_s (ext, sizeof (sMod) - (ext-sMod)); }
 
$       *module = sMod;
        }
 
$   static char buffer [_TX_BUFSIZE] = "";
$   static Win32::SYMBOL_INFO* sym = (Win32::SYMBOL_INFO*) buffer;
 
$   if (symbol)
        {
$       memset (buffer, 0, sizeof (buffer));
 
$       sym->MaxNameLen   = sizeof (buffer) - sizeof (Win32::SYMBOL_INFO) - 1;
$       sym->SizeOfStruct = sizeof (Win32::SYMBOL_INFO);
$       unsigned long long ofs = 0;
 
$       _TX_CALL (LIB_::SymFromAddr, (process, (uintptr_t) addr, &ofs, sym));
 
        if (strcmp (sym->Name, "??") == 0) {$ *sym->Name = 0; }
 
$       *symbol = sym;
        }
 
$   static Win32::IMAGEHLP_LINE64 line64 = { sizeof (line) };
 
$   if (line)
        {
$       memset (&line64, 0, sizeof (line64));
 
$       DWORD ofs = 0;
$       _TX_CALL (LIB_::SymGetLineFromAddr64, (process, (uintptr_t) addr, &ofs, &line64));
 
$       *line = &line64;
        }
 
$   if (source)
        {
$       static char buf [_TX_BUFSIZE] = "";
$       memset (buf, 0, sizeof (buf));
 
$       if (line64.FileName && line64.LineNumber)
            {
$           _txReadSource (buf, sizeof (buf) - 1, line64.FileName,
                          (int) line64.LineNumber - context, (int) line64.LineNumber + context, (int) line64.LineNumber);
 
$           *source = buf;
            }
 
        if (!*source || !**source) {$ *source = NULL; }
        }
 
$   if (!addr && process)
        {
$       _TX_CALL (LIB_::SymCleanup, (process));
 
$       process = NULL;
        }
 
$   if (symbol)
        {
$       if (strstr  (sym->Name, "::TX::")                                                  ||
           (strncmp (sym->Name, "_tx",  3) == 0 && isupper ((unsigned char) sym->Name[3])) ||
           (strncmp (sym->Name,  "tx",  2) == 0 && isupper ((unsigned char) sym->Name[2])) ||
            strncmp (sym->Name, "_tx_", 4) == 0                                            ||
            strncmp (sym->Name,  "tx_", 3) == 0)
            {
$           return true;
            }
 
$       if (!line || !line64.FileName) return false;
 
$       intptr_t len = strlen (line64.FileName) - (sizeof (__FILE__) - 1);
 
$       return (len >= 0 && _stricmp (line64.FileName + len, __FILE__) == 0) &&
               (len == 0 || line64.FileName[len-1] == '/' || line64.FileName[len-1] == '\\');
        }
 
    #undef LIB_
 
$   return false;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
intptr_t _txReadSource (char buf[], intptr_t size, const char file[],
                        int linStart /*= 0*/, int linEnd /*= INT_MIN*/, int linMark /*= INT_MIN*/)
    {
$7  assert (buf);
 
    if (!file || !*file) {$ return 0; }
 
    if (linStart < 1) {$ linStart = 1;       }
    if (linEnd == -1) {$ linEnd   = INT_MAX; }
 
$   FILE* f = NULL;
$   fopen_s (&f, file, "r");
    if (!f) {$ return 0; }
 
$   int n = 1;
    while (!feof (f))
        {
        if (n >= linStart) {$ break; }
        while (!feof (f) && fgetc (f) != '\n')
            ;
        n++;
        }
 
$   char* s = buf;
 
    #define SZ_  ( size - 3 - (s - buf) )
 
$   while (!feof (f) && SZ_ > 0)
        {
        if (n > linEnd || _txNOP (SZ_) < 0) {$ break; }
 
        if (linMark != INT_MIN)
            {$ s += _tx_snprintf_s (s, SZ_, "%s%5d: ", ((n == linMark)? "=>" : "  "), n); }
 
$       int c = 0;
$       while (!feof (f) && SZ_ > 0 && (c = fgetc (f)) != '\n') *s++ = (char) c;
        if (c == EOF) {$ s--; }
 
        if (SZ_ > 0) {$ *s++ = '\n'; }
$       n++;
        }
 
    if (n <= linEnd && SZ_ <= 0)
        {$ s += _tx_snprintf_s (s, size - (s - buf), "..."); }
 
    #undef SZ_
 
$   fclose (f);
 
    if (s > buf && s[-1] == '\n') {$ s--; }
$   *s = 0;
 
$   return (s - buf);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
const char* _txCaptureStackBackTraceTX (int framesToSkip /*= 0*/, bool readSource /*= false*/)
    {
$6  const int maxFrames = 62;  // TX says too: < 63
$   static char trace [(MAX_PATH + 1024+1) * maxFrames] = "";
 
    if (framesToSkip == -1) {$ return trace; }
 
$   memset (trace, 0, sizeof (trace));
$   char* s = trace;
 
    #define SZ_  ( sizeof (trace) - 1 - 3 - (s-trace) )
 
$   const _txLoc* loc = &_txLoc::Cur;
 
    for (int i = 0; loc && i < framesToSkip + 1; i++, loc = loc->prev) { $; }
 
$   for (int i = -framesToSkip; loc && i < maxFrames; i++, loc = loc->prev)
        {
        if (i < 0) {$ continue; }
 
        if (loc->func || loc->file || loc->line)
            {
$           s += _tx_snprintf_s     (s, SZ_, "%s#%2d in %s at %s (%d)", (i? readSource? "\n\n" : "\n" : ""),
                                     i, loc->func, loc->file, loc->line);
 
$           if (readSource)
                {
$               s += _tx_snprintf_s (s, SZ_, ":\n\n");
$               s += _txReadSource  (s, SZ_, loc->file, loc->line - 2, loc->line + 2, loc->line);
                }
            }
        }
 
    #undef SZ_
 
$   s += _tx_snprintf_s (s, sizeof (trace) - 1 - (s-trace), "");
 
$   return trace;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool _txCreateMiniDump (EXCEPTION_POINTERS* exc)
    {
$6  assert (exc);
 
$   DWORD         winErr = GetLastError();
$   int           crtErr = errno;
    #if !defined (__CYGWIN__)
$   unsigned long dosErr = _doserrno;
    #endif
 
$   static char dumpName[MAX_PATH] = "";
    if (!*dumpName) {$ _tx_snprintf_s (dumpName, sizeof (dumpName) - 1, "%s.dmp", _txLogName); }
 
$   HANDLE file = CreateFile (dumpName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 
    if (!file || file == INVALID_HANDLE_VALUE) {$ return false; }
 
$   Win32::MINIDUMP_EXCEPTION_INFORMATION excInfo = { GetCurrentThreadId(), exc, false };
 
$   bool ok = _TX_CALL (Win32::MiniDumpWriteDump, (GetCurrentProcess(), GetCurrentProcessId(), file,
                                                   (Win32::MINIDUMP_TYPE) (Win32::MiniDumpWithIndirectlyReferencedMemory | Win32::MiniDumpScanMemory),
                                                   &excInfo, NULL, NULL));
$   CloseHandle (file);
 
$   SetLastError (winErr);
$   errno = crtErr;
    #if !defined (__CYGWIN__)
$   _doserrno = dosErr;
    #endif
 
    if (ok) {$ return true;  }
    else    {$ return false; }
    }
 
//-----------------------------------------------------------------------------------------------------------------
//}
 
//-----------------------------------------------------------------------------------------------------------------
//{          Errors reporting
//-----------------------------------------------------------------------------------------------------------------
 
const char* _txProcessError (const char file[], int line, const char func[], unsigned color, const char msg[], va_list args)
    {
    _txErrors++;
 
    DWORD           winErr   = GetLastError();
 
    int             crtErr   = errno;
 
    #if !defined (__CYGWIN__)
    unsigned long   dosErr   = _doserrno;
    #else
    unsigned long   dosErr   = 0;
    #endif
 
    unsigned        oglErr   = _TX_CALL (Win32::wglGetCurrentDC, ())? _TX_CALL (Win32::glGetError, ()) : _txOGLError;
 
    unsigned        threadId = GetCurrentThreadId();
 
    enum { isFatal = 0x01, isWarning = 0x02, noMsgBox = 0x04, fmtOnly = 0x08, traceSE = 0x10 };
    unsigned options = 0;
 
    for (; msg && *msg; msg++)
        {
        if      (*msg == '\a') options |= isFatal;
        else if (*msg == '\v') options |= isWarning;
        else if (*msg == '\b') options |= noMsgBox;
        else if (*msg == '\f') options |= fmtOnly;
        else if (*msg == '\t') options |= traceSE;
        else break;
        }
 
    const char* stkTrace = NULL;
    const char*  txTrace = NULL; (void) txTrace;
 
    if (!(options & fmtOnly))
        {
        stkTrace = ((options & traceSE) && *_txTraceSE)? _txTraceSE : _txCaptureStackBackTrace   (2, true);
        txTrace  =                                                    _txCaptureStackBackTraceTX (0, true);
        }
 
    static char what[_TX_BIGBUFSIZE*10] = "";
    static char str [_TX_BIGBUFSIZE]    = "";
    char *s = what;
 
    #define     PRINT_(...)  s += _tx_snprintf_s  (s, sizeof (what) - 1 - (s - what), ##__VA_ARGS__)
    #define    VPRINT_(...)  s += _tx_vsnprintf_s (s, sizeof (what) - 1 - (s - what), ##__VA_ARGS__)
 
                PRINT_ ("TXLib %s\n\n", ((options & isWarning)? "ïðåäóïðåæäàåò:" :
                                         (options & isFatal)?   "ñîáîëåçíóåò..." :
                                                                "ñîîáùàåò:"));
                PRINT_ ("Ïðîãðàììà: %s", txGetModuleFileName());
    if (file)   PRINT_ (", ôàéë: %s",    file);
    if (line)   PRINT_ (", ñòðîêà: %d",  line);
    if (func)   PRINT_ (", ôóíêöèÿ: %s", func);
                PRINT_ (",\n\n");
 
    if (msg)    PRINT_ ("%s: ", (file || line || func)? "Ñîîáùåíèå : "ÂÍÅÇÀÏÍÎ"),
               VPRINT_ (msg, args);

    while (s > what && s[-1] == '\n') s--;

                PRINT_ ("\n\n" "#%d: %s, Instance: 0x%p (%d-bit), Flags: %c%c%c%c%c%d, Thread: 0x%X%s",

                        _txErrors, _TX_VERSION, &_txInitialized, (sizeof (void*) == 4)? 32 : 64,

                        "cC"[_txConsole], "mM"[_txMain], "dD"[_txIsDll], "rR"[_txRunning], "eE"[_txExit], _txLoc::Cur.trace,

                        threadId, (threadId == _txMainThreadId)?    " (Main)"   :
                                  (threadId == _txCanvas_ThreadId)? " (Canvas)" : "");

    if (winErr) PRINT_ (", GetLastError(): %lu (", (unsigned long) winErr),
                s += FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    NULL, winErr, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (sizeof (what) - (s-what)), NULL) - 2,
                s -=  (s[-1] == '.')? 1 : 0,
                PRINT_ (")");

    if (crtErr) PRINT_ (", errno: %d (%s)",        crtErr, (strerror_s (str, sizeof (str), crtErr), str));
    if (dosErr) PRINT_ (", _doserrno: %lu (%s)",   dosErr, (strerror_s (str, sizeof (str), dosErr), str));
    if (oglErr) PRINT_ (", glGetError(): %u (0x%04X, %s)", oglErr, oglErr, _TX_CALL (Win32::gluErrorString, (oglErr)));

    #if (__cplusplus <= 201703L)
                PRINT_ (". %s\n", ::std::uncaught_exception ()? "std::uncaught_exception(): true."  : "");
    #else
                PRINT_ (". %s\n", ::std::uncaught_exceptions()? "std::uncaught_exceptions(): true." : "");
    #endif

    if (_txLoc::Cur.inTX > 0 && file && !(_txLoc::Cur.line == line && _stricmp (_txLoc::Cur.file, file) == 0) &&
       (_txLoc::Cur.file || _txLoc::Cur.line || _txLoc::Cur.func))
                PRINT_ ("From: %s (%d) %s.\n", _txLoc::Cur.file, _txLoc::Cur.line, _txLoc::Cur.func);

    txOutputDebugPrintf ("\r" "%s - ERROR: %s\n", _TX_VERSION, what);

    if (options & fmtOnly)
        {
        SetLastError (winErr);

        errno = crtErr;

        #if !defined (__CYGWIN__)
        _doserrno = dosErr;
        #endif

        return what;
        }

    unsigned restore = txGetConsoleAttr();
    txSetConsoleAttr ((options & isFatal)? FOREGROUND_LIGHTMAGENTA : FOREGROUND_LIGHTRED);
    if (color) {$ txSetConsoleAttr (color); }

    int oldCodePage = txSetLocale();

    fprintf (stderr,      "\n" "--------------------------------------------------\n"
                               "%s\n"
                               "--------------------------------------------------\n",
                               what);

    if (stkTrace && strstr (stkTrace, ".exe: "))
        {$ fprintf (stderr,    "Ñòåê âûçîâîâ:\n\n"
                               "%s\n\n"
                               "--------------------------------------------------\n",
                               stkTrace); }

    SetConsoleOutputCP (oldCodePage);
    txSetConsoleAttr (restore);

    if (*_txLogName) do
        {
        FILE* log = NULL; fopen_s (&log, _txLogName, "a");
        if (!log) {$ break; }

        fprintf (log,     "\n" "--------------------------------------------------\n"
                               "%s\n"
                               "--------------------------------------------------\n",
                               what);

        fprintf (log,          "Ñòåê âûçîâîâ:\n\n"
                               "%s\n",
                               (*_txTraceSE? _txTraceSE : stkTrace));

        #if defined (_TX_ALLOW_TRACE) || defined (_DEBUG)

        if (_txLoc::Cur.inTX > 0 && txTrace && *txTrace)
            {
            fprintf (log, "\n" "--------------------------------------------------\n"
                               "Ñòåê âûçîâîâ TX:\n\n"
                               "%s\n",
                               txTrace);
            }

        #endif

        fprintf (log,     "\n" "--------------------------------------------------\n"
                               "%s\n\n"
                               "--------------------------------------------------\n",
                               _txAppInfo());
        fclose (log);
        break;
        }
        while (false);

    int ret = 0;

    if (!(options & noMsgBox))
        {
        txSleep (_txWindowUpdateInterval);

        PRINT_ ("\n" "Ïðåðâàòü ïðîãðàììó?");

        ret = txMessageBox (what, ((options & isWarning)? "Ïðåäóïðåæäåíèå"   :
                                   (options & isFatal)?   "Ôàòàëüíàÿ îøèáêà" :
                                                          "Îøèáêà â ïðîãðàììå"), MB_ICONSTOP | MB_SYSTEMMODAL | MB_YESNOCANCEL);
        }

    SetLastError (winErr);

    errno = crtErr;

    #if !defined (__CYGWIN__)
    _doserrno = dosErr;
    #endif

    if (((options & isFatal) && !IsDebuggerPresent()) || ret == IDYES)
        {
        txUnlock();
        _txCleanup();
        Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
        }

    #undef PRINT_

    return what;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

int _txOnErrorReport (int type, const char* text, int* ret)
    {
    assert (text);
    assert (ret);

    _txErrors++;

    unsigned restore = txGetConsoleAttr();

    switch (type)
       {
       case _CRT_WARN:   txSetConsoleAttr (FOREGROUND_LIGHTRED);     break;
       case _CRT_ERROR:  txSetConsoleAttr (FOREGROUND_LIGHTMAGENTA); break;
       case _CRT_ASSERT: txSetConsoleAttr (FOREGROUND_YELLOW);       break;
       default:                                                      break;
       }

    const char startReport[] = "Detected memory leaks!\n",
                 endReport[] = "Object dump complete.\n";

    if (strcmp (text, startReport) == 0)  // Dirty, dirty hack. À ÷òî äåëàòü?
        {
        _txOnErrorReport (type, "\n",                                                                              NULL);
        _txOnErrorReport (type, _TX_VERSION " - ERROR: ",                                                          NULL);
        _txOnErrorReport (type, "Âíèìàíèå: Îáíàðóæåíû óòå÷êè ïàìÿòè! (Äëÿ ïîèñêà èñïîëüçóéòå _TX_ALLOC_BREAK.)\n", NULL);
        _txOnErrorReport (type, "\n",                                                                              NULL);
        }

    size_t len = strlen (text);
    if (text [len-1] != '\n')               txOutputDebugPrintf ("%s",                text);
    else if (strcmp (text, endReport) != 0) txOutputDebugPrintf ("%s" "%s - ERROR: ", text, _TX_VERSION);
    else                                    txOutputDebugPrintf ("%s\n",              text);

    DWORD n = 0;
    HANDLE err = GetStdHandle (STD_ERROR_HANDLE);
    WriteFile (err, text, (DWORD) strlen (text), &n, NULL);

    txSetConsoleAttr (restore);

    if (*_txLogName) do
        {
        HANDLE log = CreateFile (_txLogName, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (log == INVALID_HANDLE_VALUE) break;

        SetFilePointer (log, 0, NULL, FILE_END);
        WriteFile (log, text, (DWORD) strlen (text), &n, NULL);

        CloseHandle (log);
        break;
        }
        while (false);

    if (ret) *ret = 0;

    return (type == _CRT_WARN);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

int txMessageBox (const char text[], const char header[], unsigned flags /*= MB_ICONINFORMATION | MB_OKCANCEL*/)
    {
$5  static wchar_t textW   [_TX_BIGBUFSIZE * sizeof (wchar_t)] = L"[NULL text]";
$   static wchar_t headerW [_TX_BUFSIZE    * sizeof (wchar_t)] = L"[NULL header]";

    if (text)   {$ MultiByteToWideChar (_TX_CODEPAGE, 0, text,   -1, textW,   sizearr (textW))   || memset (textW,   0, sizeof (textW));   }
    if (header) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, header, -1, headerW, sizearr (headerW)) || memset (headerW, 0, sizeof (headerW)); }

$   HWND wnd = _txCanvas_Window;
$   int  ret = MessageBoxW ((wnd && IsWindowVisible (wnd))? wnd : _TX_CALL (Win32::GetConsoleWindow,()),
                            textW, headerW, flags | MB_SETFOREGROUND | MB_TOPMOST | MB_OKCANCEL );
$   if (ret == IDCANCEL)
        {
$       SendNotifyMessage (txWindow(), (_txMain? WM_CLOSE : WM_DESTROY), 0, 0);
$       _txWaitFor (!_txCanvas_Window, _TX_TIMEOUT);
        }

$   return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txGetAsyncKeyState (int key)
    {
$1  HWND wnd = GetForegroundWindow();

    return (GetAsyncKeyState (key) & 0x8000) &&
           (wnd == txWindow() || wnd == Win32::GetConsoleWindow());
    }

//-----------------------------------------------------------------------------------------------------------------

bool txNotifyIcon (unsigned flags, const char title[], const char format[], ...)
    {
$5  if (_TX_ARGUMENT_FAILED (format)) return false;

$   va_list arg; va_start (arg, format);
$   bool ok = true;

    #if defined (_WIN32_IE) && (_WIN32_IE >= 0x0500)

$   NOTIFYICONDATA nid = { sizeof (nid) };

$   nid.uFlags      = NIF_ICON | NIF_TIP | NIF_INFO;
$   nid.hWnd        = NULL;
$   nid.uID         = 1;
$   nid.hIcon       = _txCreateTXIcon (16); assert (nid.hIcon);
$   strncpy_s       (nid.szTip,       sizeof (nid.szTip),       "TXLib Information", sizeof (nid.szTip));
$   strncpy_s       (nid.szInfoTitle, sizeof (nid.szInfoTitle), (title? title : "TXLib ñîîáùàåò"), sizeof (nid.szInfoTitle) - 1);
$   _tx_vsnprintf_s (nid.szInfo, sizeof (nid.szInfo), format, arg);
$   nid.dwInfoFlags = flags;

$   txOutputDebugPrintf ("\r" _TX_VERSION " - %s: %s (Icon notification)\n", nid.szInfoTitle, nid.szInfo);

$   ok &= !!Shell_NotifyIcon (NIM_ADD,    (::NOTIFYICONDATA*) &nid);
$   ok &= !!Shell_NotifyIcon (NIM_MODIFY, (::NOTIFYICONDATA*) &nid);

$   if (nid.hIcon) DestroyIcon (nid.hIcon) asserted;

    #else

$   char nid_szInfo[_TX_BUFSIZE] = "";
$   _tx_vsnprintf_s (nid_szInfo, sizeof (nid_szInfo), format, arg);
$   txOutputDebugPrintf ("\r" _TX_VERSION " - %s: %s (Icon notification - NOT displayed)\n", title, nid_szInfo);
$   ok = false;

$   (void)flags; (void)title;

    #endif

$   va_end (arg);
    return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txTrace (const char file[], int line, const char func[], const char msg[] /*= NULL*/, ...)
    {
    unsigned id = GetCurrentThreadId();

    const char marks[2][2][3] = {{"uU", "cC"}, {"mM", "??"}};

    char mark = marks [id == _txMainThreadId] [id == _txCanvas_ThreadId] [(_txLoc::Cur.inTX > 0)];

    char msgStr[_TX_BUFSIZE] = "";
    if (msg)
        {
        va_list arg; va_start (arg, msg);
        _tx_vsnprintf_s (msgStr, sizeof (msgStr) - 1, msg, arg);
        va_end (arg);
        }

    txOutputDebugPrintf ("%s - 0x%p %c%c%c%c%c%d [%c] - %-*s (%5d)  " "|%*s%s" "%s%s\n",

                         _TX_VERSION, &_txInitialized,

                         "cC"[_txConsole], "mM"[_txMain], "dD"[_txIsDll], "rR"[_txRunning], "eE"[_txExit],
                         _txLoc::Cur.trace, mark,

                         (int) sizeof (__FILE__) - 1, (file? file : "(NULL file)"), line,
                         2 * (_txLoc::Cur.inTX - 1) * !!func, "", (func? func : ""),

                         ((*msgStr && func)? ": " : ""), msgStr);
    }

//-----------------------------------------------------------------------------------------------------------------

int txOutputDebugPrintf (const char format[], ...)
    {
    if (!format) return 0;

    enum { msgbox = 1, print = 2, compr = 4 };
    int options = 0;

    for (; format && *format; format++)
        {
        if      (*format == '\a') options |= msgbox;
        else if (*format == '\f') options |= print;
        else if (*format == '\r') options |= compr;
        else break;
        }

    char text[_TX_BIGBUFSIZE] = "";

    va_list arg; va_start (arg, format);
    int n = (int) _tx_vsnprintf_s (text, sizeof (text) - 1-1, format, arg);
    va_end (arg);

    struct __ { static int trimSpaces (char str[])
        {
        char *dst = str, *src = str;

        for (char d = ' '; d; src++)
            if (isspace ((unsigned char)(*src))) { if (d != ' ') *dst++ = d = ' '; }
            else                                                 *dst++ = d = *src;

        return (int) (dst - str - 1);
        }};

    if (options & compr)  n = __::trimSpaces (text);

    OutputDebugString (text);

    if (options & print)  fprintf (stderr, "%s", text);

    if (options & msgbox) txMessageBox (text, "Îêàçûâàåòñÿ, ÷òî", MB_ICONEXCLAMATION);

    return n;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _tx_snprintf_s (char stream[], intptr_t size, const char format[], ...)
    {
    if (!format) return 0;

    va_list arg; va_start (arg, format);
    intptr_t ret = _tx_vsnprintf_s (stream, size, format, arg);
    va_end (arg);

    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _tx_vsnprintf_s (char stream[], intptr_t size, const char format[], va_list arg)
    {
    if (!stream || !format) return 0;

    #if defined (_TRUNCATE)
    intptr_t ret = _vsnprintf_s (stream, size, _TRUNCATE, format, arg);
    #else
    intptr_t ret = _vsnprintf   (stream, size,            format, arg);
    #endif

    if (ret < 0 && size >= 4)
        {
        const char ellipsis[] = "...";
        size_t     szEllipsis = sizeof (ellipsis) - 1;

        strncpy_s (stream + size - szEllipsis, szEllipsis+1, ellipsis, szEllipsis);
        }

    return (ret >= 0)? ret : size;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (__CYGWIN__)

int _getch()
    {
    termios oldattr = {}; tcgetattr (STDIN_FILENO, &oldattr);

    termios newattr = oldattr;
    newattr.c_lflag &= ~(ICANON | ECHO);
    tcsetattr (STDIN_FILENO, TCSANOW, &newattr);

    int ch = getchar();

    tcsetattr (STDIN_FILENO, TCSANOW, &oldattr);

    return ch;
    }

//-----------------------------------------------------------------------------------------------------------------

int _putch (int ch)
    {
    termios old = {}; tcgetattr (STDOUT_FILENO, &old);

    termios cur = old;
    cur.c_lflag &= ~ICANON;
    cur.c_lflag |=  ECHO;
    tcsetattr (STDOUT_FILENO, TCSANOW, &cur);

    putchar (ch);

    tcsetattr (STDOUT_FILENO, TCSANOW, &old);

    return ch;
    }

//-----------------------------------------------------------------------------------------------------------------

int _kbhit()
    {
    termios old = {}; tcgetattr (STDIN_FILENO, &old);

    termios cur = old;
    cur.c_lflag &= ~(ICANON | ECHO);
    cur.c_cc[VMIN]  = 1;
    cur.c_cc[VTIME] = 0;

    tcsetattr (STDIN_FILENO, TCSAFLUSH, &cur);

    fd_set  fd = {}; FD_SET (STDIN_FILENO, &fd);
    timeval tv = {};

    int res = select (STDIN_FILENO + 1, &fd, NULL, NULL, &tv) && FD_ISSET (STDIN_FILENO, &fd);

    tcsetattr (STDIN_FILENO, TCSAFLUSH, &old);

    return res;
    }

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Information
//-----------------------------------------------------------------------------------------------------------------

const char* txGetModuleFileName (bool fileNameOnly /*= true*/)
    {
    static char name[MAX_PATH] = "";

    if (!*name)
        {
        if (!GetModuleFileName (NULL, name, sizeof (name) - 1)) *name = 0;

        char* ext = strrchr (name, '.');
        if (ext) _strlwr_s (ext, sizeof (name) - 1 - (ext - name));
        }

    assert (*name);

    if (fileNameOnly) return name;

    static char fullName[MAX_PATH] = "";
    strncpy_s (fullName, sizeof (fullName), name, sizeof (fullName) - 1);

    char* title = strrchr (fullName, '\\'); if (!title) title = fullName;
    char* ext   = strrchr (fullName,  '.'); if (!ext)   ext   = fullName + strlen (fullName);

    size_t sz = sizeof (fullName) - (ext - fullName);
    strncpy_s (ext, sz-1, " - TXLib", sz);

    return title + 1;
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txAppInfo()
    {
$1  time_t timeT     = time (NULL) - clock()/CLOCKS_PER_SEC;
    char   timeS[32] = "";
    ctime_s (timeS, sizeof (timeS), &timeT);

    static char text[_TX_BUFSIZE] = "";
    char cwd [MAX_PATH] = "";

    _tx_snprintf_s (text, sizeof (text) - 1,

                    "Developed with:\n\n"
                    "The Dumb Artist Library (TX Library)\n"
                    _TX_VERSION "\n" _TX_AUTHOR "\n"
                    "See license on: http://txlib.ru\n\n"

                    "TXLib file:" "\t" __FILE__ "\n"
                    "Compiled:"   "\t" __DATE__ " " __TIME__ ", " __TX_COMPILER__ ", %s, %d-bit, " _TX_BUILDMODE "\n"
                    "Started:"    "\t" "%.6s %.4s %.8s\n\n"

                    "Run file:"   "\t" "%s\n"
                    "Directory:"  "\t" "%s",

    #if   defined (_MSC_VER)
                    "MSVC Runtime",
    #elif defined (__CYGWIN__)
                    "Cygwin Runtime",
    #elif defined (_GCC_VER) && defined (_WIN64)
                    __mingw_get_crt_info(),
    #else
                    "MinGW Runtime " TX_QUOTE (__MINGW32_MAJOR_VERSION) "." TX_QUOTE (__MINGW32_MINOR_VERSION),
    #endif
                    (sizeof (void*) == sizeof (DWORD))? 32 : 64,

                    timeS + 4, timeS + 20, timeS + 11,              // These offsets are ANSI standardized
                    txGetModuleFileName(),
                    _getcwd (cwd, sizeof (cwd) - 1));

    return text;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib API implementation
//           Ðåàëèçàöèÿ TXLib API
//=================================================================================================================

inline const char* txVersion()
    {
    return _TX_VERSION;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txVersionNumber()
    {
    return _TX_VER;
    }

//-----------------------------------------------------------------------------------------------------------------

inline HWND txWindow()
    {
$0  return _txCanvas_Window;
    }

//-----------------------------------------------------------------------------------------------------------------

inline HDC& txDC()
    {
$0  return _txCanvas_BackBuf[0];
    }

//-----------------------------------------------------------------------------------------------------------------

inline RGBQUAD* txVideoMemory()
    {
    return _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetExtent (HDC dc /*= txDC()*/)
    {
$0  static POINT err = {-1, -1};

    if (!dc) {$ POINT screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) }; return screen; };

    if (_TX_DEFAULT_HDC_FAILED (dc)) {$ return err; }

$   BITMAP bmap = {};
$   txGDI (Win32::GetObject (Win32::GetCurrentObject (dc, OBJ_BITMAP), sizeof (bmap), &bmap), dc) asserted;

$   POINT  size = { bmap.bmWidth, bmap.bmHeight };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetExtentX (HDC dc /*= txDC()*/)
    {
    return txGetExtent (dc) .x;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetExtentY (HDC dc /*= txDC()*/)
    {
    return txGetExtent (dc) .y;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDestroyWindow (HWND wnd /*= txWindow()*/)
    {
$1  if (!wnd || !txWindow()) return false;

$   if (wnd != txWindow())
        {
$       return !!SendNotifyMessage (txWindow(), _TX_WM_DESTROYWND, 0, (LPARAM) wnd);
        }

$   if (SendNotifyMessage (txWindow(), (_txMain? WM_CLOSE : WM_DESTROY), 0, 0) == 0) return false;

$   if (_txMain)
        {
$       txNotifyIcon (NIIF_WARNING, NULL, "\n" "Î÷åíü, î÷åíü ïëîõî çàâåðøàòü ïðîãðàììó ÷åðåç txDestroyWindow().\n\n"
                                               "Âîçâðàùàéòåñü ÷åðåç main(), òàì âàì áóäóò ðàäû.\n");
$       Sleep (_TX_TIMEOUT);
        }

$   _txWaitFor (!_txCanvas_Window, _TX_TIMEOUT);

$   return _txCanvas_Window == NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

HPEN txSetColor (COLORREF color, double thickness /*= 1*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return NULL;

$   HPEN pen = Win32::CreatePen ((color == TX_TRANSPARENT? PS_NULL : PS_SOLID), ROUND (thickness), color);

$   if (!pen) return (HPEN) NULL;

$   if (!_txBuffer_Select (pen, dc))
        {
$       Win32::DeleteObject (pen);
$       return (HPEN) NULL;
        }

$   if (txGDI (Win32::SetTextColor (dc, color), dc) == CLR_INVALID)
        {$ return (HPEN) NULL; }

$   return pen;
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txColor (double red, double green, double blue)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;

$   COLORREF color = RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255));

$   return txSetColor (color)? color : CLR_INVALID;
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txGetColor (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;

$   HGDIOBJ obj = txGDI ((Win32::GetCurrentObject (dc, OBJ_PEN)), dc);
$   assert (obj); if (!obj) return CLR_INVALID;

$   union { EXTLOGPEN extLogPen; LOGPEN LogPen; } buf = {};

$   int size = Win32::GetObject (obj, 0, NULL);
$   Win32::GetObject (obj, sizeof (buf), &buf) asserted;

$   return (size == sizeof (LOGPEN))? buf.LogPen.lopnColor : buf.extLogPen.elpColor;
    }

//-----------------------------------------------------------------------------------------------------------------

HBRUSH txSetFillColor (COLORREF color, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return NULL;

$   HBRUSH brush = (color == TX_TRANSPARENT)? (HBRUSH) Win32::GetStockObject (HOLLOW_BRUSH) : Win32::CreateSolidBrush (color);

$   return (_txBuffer_Select (brush, dc))? brush : (Win32::DeleteObject (brush), (HBRUSH) NULL);
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txFillColor (double red, double green, double blue)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;

$   COLORREF color = RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255));

$   return txSetFillColor (color)? color : CLR_INVALID;
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txGetFillColor (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;

$   HGDIOBJ obj = txGDI ((Win32::GetCurrentObject (dc, OBJ_BRUSH)), dc);
$   assert (obj); if (!obj) return CLR_INVALID;

$   LOGBRUSH buf = {};
$   txGDI ((Win32::GetObject (obj, sizeof (buf), &buf)), dc) asserted;

$   return buf.lbColor;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClear (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT size = txGetExtent (dc);
$   return txGDI (!!(Win32::PatBlt (dc, 0, 0, size.x, size.y, PATCOPY)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txSetPixel (double x, double y, COLORREF color, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   txGDI ((Win32::SetPixel (dc, ROUND (x), ROUND (y), color)), dc);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txPixel (double x, double y, double red, double green, double blue, HDC dc /*= txDC()*/)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;

$   return txSetPixel (x, y, RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

inline COLORREF txGetPixel (double x, double y, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;

$   return txGDI ((Win32::GetPixel (dc, ROUND (x), ROUND (y))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLine (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   bool ok  = txGDI ((Win32::MoveToEx (dc, ROUND (x0), ROUND (y0), NULL)), dc);
$        ok &= txGDI ((Win32::LineTo   (dc, ROUND (x1), ROUND (y1)      )), dc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txRectangle (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   return txGDI ((Win32::Rectangle (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPolygon (const POINT points[], int numPoints, HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (points)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))     return false;

$   return txGDI (!!(Win32::Polygon (dc, points, numPoints)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txEllipse (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   return txGDI ((Win32::Ellipse (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txCircle (double x, double y, double r)
    {
$1  return txEllipse (x-r, y-r, x+r, y+r);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txArc (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };

$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;

$   return txGDI (!!(Win32::Arc (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                     ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                     ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPie (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };

$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;

$   return txGDI (!!(Win32::Pie (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                     ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                     ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txChord (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };

$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;

$   return txGDI (!!(Win32::Chord (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                       ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                       ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txFloodFill (double x, double y,
                  COLORREF color /*= TX_TRANSPARENT*/, DWORD mode /*= FLOODFILLSURFACE*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   if (color == TX_TRANSPARENT) color = txGetPixel (x, y, dc);

$   return txGDI (!!(Win32::ExtFloodFill (dc, ROUND (x), ROUND (y), color, mode)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextOut (double x, double y, const char text[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (text)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return false;

$   int len = (int) strlen (text);
$   bool ok = txGDI (!!(Win32::TextOut (dc, ROUND (x), ROUND (y), text, len)), dc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDrawText (double x0, double y0, double x1, double y1, const char text[],
                 unsigned format /*= DT_CENTER | DT_VCENTER | DT_WORDBREAK | DT_WORD_ELLIPSIS*/,
                 HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (text)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return false;

#if !defined (NDEBUG)

$   if (x0 > x1)
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïàðàìåòð x0 = %lg áîëüøå, ÷åì x1 = %lg. Òåêñò âûâîäèòüñÿ íå áóäåò.", x0, x1);
        }

$   if (y0 > y1)
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïàðàìåòð y0 = %lg áîëüøå, ÷åì y1 = %lg. Òåêñò âûâîäèòüñÿ íå áóäåò.", y0, y1);
        }

#endif

$   RECT r = { ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1) };

$   if (!strchr (text, '\n')) format |= DT_SINGLELINE;

$   unsigned prev = txSetTextAlign (TA_LEFT | TA_TOP | TA_NOUPDATECP, dc);

$   bool ok = false;

$   if (Win32::DrawText)
        {
$       ok = !!txGDI ((Win32::DrawText (dc, text, -1, &r, format)), dc);
$       Win32::GetPixel (dc, 0, 0);
$       ok = true;
        }
    else
        {
$       txTextOut ((x0 + x1) / 2, (y0 + y1) / 2, text);
$       ok = false;
        }

$   txSetTextAlign (prev, dc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

HFONT txSelectFont (const char name[], double sizeY, double sizeX /*= -1*/,
                    int bold /*= FW_DONTCARE*/, bool italic /*= false*/, bool underline /*= false*/,
                    bool strikeout /*= false*/, double angle /*= 0*/,
                    HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (name)) return NULL;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return NULL;

$   HFONT font = txFontExist (name)?
                     Win32::CreateFont (ROUND (sizeY), ROUND ((sizeX >= 0)? sizeX : sizeY/3),
                                        ROUND (angle*10), 0, bold, italic, underline, strikeout,
                                        RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                        DEFAULT_QUALITY, DEFAULT_PITCH, name)
                     :
                     (HFONT) Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, dc);

$   return font;
    }

//-----------------------------------------------------------------------------------------------------------------

SIZE txGetTextExtent (const char text[], HDC dc /*= txDC()*/)
    {
$1  SIZE size = {-1, -1};

$   if (_TX_ARGUMENT_FAILED    (text)) return size;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return size;

$   size_t len = strlen (text);
$   txGDI ((Win32::GetTextExtentPoint32 (dc, text, (int) len, &size)), dc) asserted;

$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetTextExtentX (const char text[], HDC dc /*= txDC()*/)
    {
$1  return txGetTextExtent (text, dc) .cx;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetTextExtentY (const char text[], HDC dc /*= txDC()*/)
    {
$1  return txGetTextExtent (text, dc) .cy;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetTextAlign (unsigned align /*= TA_CENTER | TA_BASELINE*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   return txGDI ((Win32::SetTextAlign (dc, align)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

LOGFONT* txFontExist (const char name[])
    {
$1  if (_TX_ARGUMENT_FAILED (name)) return NULL;

$   static LOGFONT font = {};
$   font.lfCharSet = DEFAULT_CHARSET;
$   strncpy_s (font.lfFaceName, sizeof (font.lfFaceName), name, sizeof (font.lfFaceName) - 1);

$   struct tools
        {
        static int CALLBACK enumFonts (const LOGFONT* fnt, const TEXTMETRIC*, DWORD, LPARAM data)
            {
$           if (_TX_ARGUMENT_FAILED (fnt))  return 0;
$           if (_TX_ARGUMENT_FAILED (data)) return 0;

            #ifndef __STRICT_ANSI__
$           return _strnicmp (fnt->lfFaceName, ((LOGFONT*)data)->lfFaceName, LF_FACESIZE);

            #else
$           return  strncmp  (fnt->lfFaceName, ((LOGFONT*)data)->lfFaceName, LF_FACESIZE);

            #endif
            }
        };

$   return txGDI ((Win32::EnumFontFamiliesEx (NULL, &font, tools::enumFonts, (LPARAM) &font, 0)), NULL) == 0? &font : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSelectObject (HGDIOBJ obj, HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (obj)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))  return false;

$   return _txBuffer_Select (obj, dc);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txCreateCompatibleDC (double sizeX, double sizeY, HBITMAP bitmap /*= NULL*/)
    {
$1  POINT size = { ROUND (sizeX), ROUND (sizeY) };

$   HDC dc = _txBuffer_Create (NULL, &size, bitmap);
$   assert (dc); if (!dc) return NULL;

$   txSetDefaults (dc);

$   if (!_txCanvas_UserDCs) return dc;

$   txAutoLock _lock;
$   _txCanvas_UserDCs->push_back (dc);

$   if (_txCanvas_UserDCs->size() >= _TX_BUFSIZE)
        {$ txNotifyIcon (NIIF_WARNING, NULL, "Âû çàãðóçèëè óæå %d HDC, ñèñòåìå ìîæåò ñòàòü ïëîõî.", (int) _txCanvas_UserDCs->size()); }

$   return dc;
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txCreateDIBSection (double sizeX, double sizeY, RGBQUAD** pixels /*= NULL*/)
    {
$1  RGBQUAD* buf = NULL;
$   if (!pixels) pixels = &buf;

$   BITMAPINFO info = {{ sizeof (info), ROUND (sizeX), ROUND (sizeY), 1, WORD (sizeof (RGBQUAD) * 8), BI_RGB }};

$   HDC dc = txCreateCompatibleDC (0, 0, Win32::CreateDIBSection (NULL, &info, DIB_RGB_COLORS, (void**) pixels, NULL, 0));

$   RGBQUAD black = { 0, 0, 0, 255 };
$   for (int i = 0; i < sizeX * sizeY; i++) (*pixels)[i] = black;

$   return dc;
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txCreateDIBSection (double sizeX, double sizeY, COLORREF** pixels)
    {
$1  return txCreateDIBSection (sizeX, sizeY, (RGBQUAD**) pixels);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txLoadImage (const char filename[], unsigned imageFlags /*= IMAGE_BITMAP*/, unsigned loadFlags /*= LR_LOADFROMFILE*/)
    {
$1  if (_TX_ARGUMENT_FAILED (filename && *filename)) return NULL;

$   HBITMAP image = (HBITMAP) Win32::LoadImage ((loadFlags & LR_LOADFROMFILE)? NULL : GetModuleHandle (NULL),
                                                 filename, imageFlags, 0, 0, loadFlags);
$   if (!image) return NULL;

$   HDC dc = txCreateCompatibleDC (0, 0, image);

$   if (!(loadFlags & LR_LOADFROMFILE)) return dc;

$   static std::map <std::string, unsigned> loadTimes;
$   std::string file = filename;
$   unsigned time    = GetTickCount();

$   if ((long) (time - loadTimes [file]) < _TX_TIMEOUT)
        {$ txNotifyIcon (NIIF_WARNING, NULL, "Âû çàãðóæàåòå \"%s\" ñëèøêîì ÷àñòî, ïðîãðàììà áóäåò òîðìîçèòü.", filename); }

$   loadTimes [file] = time;

$   return dc;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDeleteDC (HDC* pdc)
    {
$1  if (_TX_ARGUMENT_FAILED (pdc)) return false;

$   HDC  dc = *pdc;
$   bool ok = _txBuffer_Delete (pdc);
$   if (!ok) return false;

$   if (!_txCanvas_UserDCs) return ok;

$   txAutoLock _lock;
$   std::vector <HDC> ::iterator it = std::find (_txCanvas_UserDCs->begin(), _txCanvas_UserDCs->end(), dc);
$   if  (it != _txCanvas_UserDCs->end()) { std::swap (*it, _txCanvas_UserDCs->back()); _txCanvas_UserDCs->pop_back(); }

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDeleteDC (HDC dc)
    {
$1  return txDeleteDC (&dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txBitBlt (HDC destImage,   double xDest, double yDest, double width, double height,
               HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, unsigned operation /*= SRCCOPY*/)
    {
$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;

$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;

$   return txGDI (!!(Win32::BitBlt (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                    sourceImage, ROUND (xSource), ROUND (ySource), operation)), destImage);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txBitBlt (double xDest, double yDest, HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txBitBlt (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTransparentBlt (HDC destImage,   double xDest, double yDest, double width, double height,
                       HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, COLORREF transColor /*= TX_BLACK*/)
    {
$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;

$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;

#if !defined (NDEBUG)

$   if (!(0 <= xSource && xSource + width  <= size.x &&
          0 <= ySource && ySource + height <= size.y))
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïðÿìîóãîëüíèê êîïèðóåìîé îáëàñòè {%lg, %lg, %lg, %lg} íå ïîëíîñòüþ ëåæèò âíóòðè èçîáðàæåíèÿ-èñòî÷íèêà {%d, %d, %d, %d}, "
                  "ôóíêöèÿ txTransparentBlt() ðàáîòàòü íå áóäåò.", xSource, ySource, xSource + width, ySource + height, 0, 0, (int) size.x, (int) size.y);
        }

#endif

$   bool ok = (Win32::TransparentBlt != NULL);

$   if (ok)
        {
$       ok &= txGDI (!!(Win32::TransparentBlt (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                               sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), transColor)),
                                               destImage);
        }
    else
        {
$       ok &= txGDI (!!(Win32::BitBlt         (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                               sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                               destImage);
        }

    return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txTransparentBlt (double xDest, double yDest, HDC sourceImage,
                              COLORREF transColor /*= TX_BLACK*/, double xSource /*= 0*/, double ySource /*= 0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txTransparentBlt (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, transColor);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txAlphaBlend (HDC destImage,   double xDest, double yDest, double width, double height,
                   HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
    // Ýòî ïðîâåðêè òîãî, ïðàâèëüíûå ëè HDC âû ïåðåäàëè â ôóíêöèþ.
    // Íå áîéòåñü äîëëàðîâ - <s>ýòî íå çàïðåùåííàÿ âàëþòà</s> ýòî ìàêðîñû äëÿ îòëàäêè TXLib'à.

$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;

    // Ýòî àâòîìàòè÷åñêîå îïðåäåëåíèå ðàçìåðîâ êàðòèíêè (òî÷íåå, HDC èñòî÷íèêà - source) ñ ïîìîùüþ txGetExtent().

$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;

    // Ýòî ïðîâåðêà òîãî, ÷òî êàðòèíêà (èëè åå ÷àñòü) ïðàâèëüíî ïîïàäàåò â îêíî (òî÷íåå, HDC ïðèåìíèêà - destination, dest).
    // Åñëè îíà "âûëåçàåò" èç îêíà â ëþáóþ ñòîðîíó, òî Win32::AlphaBlend íå áóäåò ðàáîòàòü. Ýòà ïðîâåðêà ïðîèñõîäèò òîëüêî
    // â ðåæèìå îòëàäêè (êîãäà íå çàäàí ìàêðîñ NDEBUG - No Debugging, áåç îòëàäêè).

#if !defined (NDEBUG)

$   if (!(0 <= xSource && xSource + width  <= size.x &&
          0 <= ySource && ySource + height <= size.y))
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïðÿìîóãîëüíèê êîïèðóåìîé îáëàñòè {%lg, %lg, %lg, %lg} íå ïîëíîñòüþ ëåæèò âíóòðè èçîáðàæåíèÿ-èñòî÷íèêà {%d, %d, %d, %d}, "
                  "ôóíêöèÿ txAlphaBlend() ðàáîòàòü íå áóäåò.", xSource, ySource, xSource + width, ySource + height, 0, 0, (int) size.x, (int) size.y);
        }

#endif

    // Ýòî íà ñëó÷àé, åñëè ïàðàìåòð alpha âûëåçàåò çà äèàïàçîí [0..1].

$   if (alpha < 0) alpha = 0;
$   if (alpha > 1) alpha = 1;

    // Îá ýòîì ñì. íèæå.

$   BITMAP bmap = { 0, 0, 0, 0, 0, 24 };
$   bool ok = !!Win32::GetObject (txGDI ((Win32::GetCurrentObject (sourceImage, OBJ_BITMAP)), sourceImage), sizeof (bmap), &bmap);

    //
    // * Ñòðóêòóðà BLENDFUNCTION *
    //
    // Ýòà ñòðóêòóðà îïðåäåëÿåò, êàê öâåòà ïèêñåëåé îêíà (òî÷íåå, source DC) è êàðòèíêè ñìåøèâàþòñÿ ïðè ðèñîâàíèè ñ ó÷åòîì
    // ïðîçðà÷íîñòè.
    //
    // Ïàðàìåòðû ñìåøèâàíèÿ ïîìåùàþòñÿ â ãðóïïó èç ïåðåìåííûõ - òàê íàçûâàåìóþ ñòðóêòóðó. Ïåðåìåííûå, âõîäÿùèå â ñòðóêòóðó,
    // íàçûâàþòñÿ êîìïîíåíòàìè ñòðóêòóðû.
    //
    //  ýòîé ñòðóêòóðå áîëåå âñåõ âàæåí åå òðåòèé êîìïîíåíò (ñì. íèæå), çàäàþùèé ïðîçðà÷íîñòü êàðòèíêè.
    // Åñëè îí ðàâåí íóëþ - òî êàðòèíêà áóäåò ñ÷èòàòüñÿ ïîëíîñòüþ ïðîçðà÷íîé è âûçîâ Win32::AlphaBlend íè÷åãî íå íàðèñóåò.
    // Åñëè îí ðàâåí 255  - òî êàðòèíêà ñêîïèðóåòñÿ â îêíî ïîëíîñòüþ, áåç ýôôåêòà ïðîçðà÷íîñòè.
    //
    // Ñ ïîìîùüþ ÷åòâåðòîãî êîìïîíåíòà ñòðóêòóðû ñèñòåìà ðèñîâàíèÿ Windows (Win32 GDI) óçíàåò, íàäî ëè ó÷èòûâàòü àëüôà-êàíàë
    // â êîïèðóåìîé êàðòèíêå èëè åãî íàäî èãíîðèðîâàòü. Åñëè â êàðòèíêå ôàêòè÷åñêè åñòü ïðàâèëüíî ïîñòðîåííûé àëüôà-êàíàë
    // (ñì. îïèñàíèå ôóíêöèè txAlphaBlend â ñèñòåìå ïîìîùè TXLib), òî ÷åòâåðòûé êîìïîíåíò ñòðóêòóðû íàäî çàäàòü êàê êîíñòàíòó
    // AC_SRC_ALPHA.
    //
    // Åñëè â êàðòèíêå àëüôà-êàíàëà ôàêòè÷åñêè íåò, òî ÷åòâåðòûé ïàðàìåòð íàäî óñòàíîâèòü â 0.
    //
    //  êîäå íèæå ÷åòâåðòûé ïàðàìåòð îïðåäåëÿåòñÿ àâòîìàòè÷åñêè èç âûçîâà Win32::GetObject(), äëÿ óíèâåðñàëüíîñòè ïðèìåíåíèÿ
    // ôóíêöèè txAlphaBlend().
    //
    // Ïîæàëóéñòà, íå íàäî áåçäóìíî êîïèðîâàòü ñåáå â ïðîãðàììó ýòîò êîä. Îñìûñëèòå åãî, è ðåøèòå, áóäåòå ëè âû èñïîëüçîâàòü
    // àëüôà-êàíàë èëè íåò, è óñòàíîâèòå ÷åòâåðòûé ïàðàìåòð ñòðóêòóðû ëèáî AC_SRC_ALPHA, ëèáî 0. Èíà÷å ýòèì êîïèïàñòîì âû
    // ïîðîäèòå íåâíÿòíûé ïàëåíûé êîä è áåçíàäåæíî èñïîðòèòå ñåáå êàðìó. :((
    //
    // Íà äîëëàðû ($) íå îáðàùàéòå âíèìàíèÿ, îíè íóæíû äëÿ îòëàäêè áèáëèîòåêè TXLib. Â âàøåé ïðîãðàììå èõ èñïîëüçîâàòü íå íàäî.
    //
    //                       ____1____   2   ___________3___________     _______________________4________________________
    //                      /         \  |  /                       \   /                                                \.

$   BLENDFUNCTION blend = { AC_SRC_OVER, 0, (BYTE) ROUND (alpha * 255), (BYTE) ((bmap.bmBitsPixel == 32)? AC_SRC_ALPHA : 0) };

    //
    // * Âûçîâ ñòàíäàðòíîé ôóíêöèè Win32::AlphaBlend() *
    //
    // Íèæå - ýòî âûçîâ Win32::AlphaBlend(). Îí òàê óñòðîåí, ÷òî, åñëè âäðóã ÷òî-òî íå ïîëó÷èëîñü (ò.å. Win32::AlphaBlend()
    // âåðíåò 0), òî òîãäà áóäåò âûçâàíà Win32::BitBlt(), êîòîðàÿ ïðîñòî ñêîïèðóåò êàðòèíêó áåç ó÷åòà ïðîçðà÷íîñòè. Ïîãóãëèòå
    // "Windows AlphaBlend function" è ïî÷èòàéòå ïðî åå ïàðàìåòðû.
    //
    // Êàê âèäèòå, îðèãèíàëüíàÿ ôóíêöèÿ èç Win32 ïðèíèìàåò ðàçìåðû íå òîëüêî èñõîäíîé, íî è èòîãîâîé êàðòèíêè, è åñëè îíè íå
    // ñîâïàäàþò, òî êàðòèíêà áóäåò óìåíüøåíà èëè óâåëè÷åíà. TXlib'îâñêàÿ <s>ïàëåíàÿ</s> ôóíêöèÿ txAlphaBlend ïðåäïîëàãàåò, ÷òî
    // ýòè ðàçìåðû âñåãäà ñîâïàäàþò, è ïîýòîìó ïðè ðàáîòå ñ txAlphaBlend() ìàñøòàá áóäåò âñåãäà 1:1. <s>Òàê ñåáå ðåøåíèå, íî</s>
    // ýòî ñäåëàíî äëÿ óïðîùåíèÿ âûçîâà ôóíêöèè txAlphaBlend().

$   if (Win32::AlphaBlend) // Òîëüêî òî, ÷òî ýòè ïàðàìåòðû ïåðåäàþòñÿ îäèíàêîâûìè, íå äàåò âîçìîæíîñòü ìåíÿòü ìàñøòàá êàðòèíêè!   // <<--
        {                  //                           //                                       vvvvv          vvvvvv            // <<--
$       ok &= txGDI (!!(Win32::AlphaBlend (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),          // <<==
                                           sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), blend)), // <<==
                                           destImage);  //                                       ^^^^^          ^^^^^^            // <<--
        }                  //                                                                    |||||          ||||||            // <<--
                           // Ñì. "AlphaBlend function" â Google, èùèòå ñìûñë ïàðàìåòðîâ wSrc è wDest (hSrc è hDest). Äóìàéòå!    // <<--

    else
        {
$       ok &= txGDI (!!(Win32::BitBlt     (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                           sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                           destImage);
$       ok = false;
        }

    //  ýòîé ôóíêöèè ïðîâåðîê è êîììåíòàðèåâ áîëüøå, ÷åì ðàáî÷åãî êîäà, è ýòî êàê áû íàìåêàåò, ÷òî íåòðóäíî ñäåëàòü ñâîþ
    // àíàëîãè÷íóþ ôóíêöèþ áåç îãðàíè÷åíèé ìàñøòàáà îòîáðàæåíèÿ. <s>Åñëè òû äî÷èòàë äî ýòîãî ìåñòà,</s> ïåðåñÿäü ñ èãëû TXLib'à
    // íà ïîâåðõíîñòü GDI Win32, <s>õîòÿ GDI òîæå òàê ñåáå, òàê ÷òî ëó÷øå çàþçàé GDI+, SFML, OpenGL èëè DirectX, áóäåò êðóòî.
    // Õîòÿ ýòî è ñëîæíåå.</s>

    // Íî ïîìíè ïðî ïàëåíûé êîïèïàñò è êàðìó, ñì. âûøå. ß ïðåäóïðåäèë.

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txAlphaBlend (double xDest, double yDest, HDC sourceImage,
                          double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txAlphaBlend (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, alpha);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txUseAlpha (HDC image)
    {
$1  if (_TX_HDC_FAILED (image)) return NULL;

$   HBITMAP bitmap = (HBITMAP) Win32::GetCurrentObject (image, OBJ_BITMAP);
$   if (!bitmap) return NULL;

$   DIBSECTION dib = {};
$   Win32::GetObject (bitmap, sizeof (dib), &dib) asserted;

$   POINT      size = {  dib.dsBm.bmWidth, dib.dsBm.bmHeight };
$   BITMAPINFO info = {{ sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB }};
$   RGBQUAD*   buf  = NULL;

$   bool isDIB = (dib.dsBm.bmPlanes        == 1                    &&
                  dib.dsBm.bmBitsPixel     == sizeof (RGBQUAD) * 8 &&
                  dib.dsBmih.biCompression == DIB_RGB_COLORS       &&
                  dib.dsBm.bmBits);
$   if (!isDIB)
        {
$       buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$       if (!buf) return NULL;

$       Win32::GetDIBits (image, bitmap, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;
        }
    else
        {
$       buf = (RGBQUAD*) dib.dsBm.bmBits;
        }

$   for (int y = 0; y < size.y; y++)
    for (int x = 0; x < size.x; x++)
        {
        RGBQUAD* color = &buf [x + y * size.x];  // Get color at (x, y) within image buffer

        color->rgbRed   = (BYTE) ROUND (color->rgbRed   * color->rgbReserved / 255.0);
        color->rgbGreen = (BYTE) ROUND (color->rgbGreen * color->rgbReserved / 255.0);
        color->rgbBlue  = (BYTE) ROUND (color->rgbBlue  * color->rgbReserved / 255.0);
        }

$   if (!isDIB)
        {
$       Win32::SetDIBitsToDevice (image, 0, 0, size.x, size.y, 0, 0, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;

$       delete[] buf;
        }

$   return image;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSaveImage (const char filename[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (filename)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))       return false;

$   POINT size = txGetExtent (dc);

$   size_t szHdrs = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER),
           szImg  = (size.x * size.y) * sizeof (RGBQUAD);

$   BITMAPFILEHEADER hdr  = { 0x4D42 /* 'MB' */, (DWORD) (szHdrs + szImg), 0, 0, (DWORD) szHdrs };
$   BITMAPINFOHEADER info = { sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB };

$   bool ok = true;

$   RGBQUAD* buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$   ok &= (buf != NULL);

$   if (ok) Win32::GetDIBits (dc, (HBITMAP) Win32::GetCurrentObject (dc, OBJ_BITMAP), 0, size.y,
                              buf, (BITMAPINFO*) &info, DIB_RGB_COLORS) asserted;
$   FILE* f = NULL;
$   if (ok) fopen_s (&f, filename, "wb");
$   ok &= (f != NULL);

$   if (ok) ok &= (fwrite (&hdr,  sizeof (hdr),  1, f) == 1);
$   if (ok) ok &= (fwrite (&info, sizeof (info), 1, f) == 1);
$   if (ok) ok &= (fwrite (buf,   szImg,         1, f) == 1);

$   ok &= (f && fclose (f) == 0);

$   delete[] buf;
$   buf = NULL;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline void txRedrawWindow()
    {
$1  txSleep (0);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txUpdateWindow (int update /*= true*/)
    {
$1  return _txCanvas_SetRefreshLock (update >= 0? !update : -update);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txBegin()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock + 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txEnd()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock - 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

double txSleep (double time)
    {
$1  LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   int lock = _txCanvas_RefreshLock;
$   _txCanvas_RefreshLock = 0;

$   HWND wnd = txWindow();
    if (wnd) {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   Sleep (ROUND ((time >= 0)? time : 0));

$   _txCanvas_RefreshLock = lock;

$   LARGE_INTEGER stop = {};
$   QueryPerformanceCounter (&stop) asserted;

$   return 1000.0 * (double) (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLock (bool wait /*= true*/)
    {
$0  if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);

$   if (wait) {$ return      EnterCriticalSection (&_txCanvas_LockBackBuf), true; }
    else      {$ return !!TryEnterCriticalSection (&_txCanvas_LockBackBuf);       }
    }

//-----------------------------------------------------------------------------------------------------------------

bool txUnlock()
    {
$0  LeaveCriticalSection (&_txCanvas_LockBackBuf);

$   if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T txUnlock (T value)
    {
$1  txUnlock();
$   return value;
    }

//-----------------------------------------------------------------------------------------------------------------

inline POINT txMousePos()
    {
$1  POINT pos = {};
$   GetCursorPos (&pos);

$   if (txWindow())
        {$ ScreenToClient (txWindow(), &pos); }

$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseX()
    {
    return txMousePos() .x;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseY()
    {
    return txMousePos() .y;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txMouseButtons()
    {
$1  return ((GetAsyncKeyState (VK_LBUTTON) & 0x8000) >> 15) |  // MSB to bit 0
           ((GetAsyncKeyState (VK_RBUTTON) & 0x8000) >> 14) |  // MSB to bit 1
           ((GetAsyncKeyState (VK_MBUTTON) & 0x8000) >> 13);   // MSB to bit 2
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetConsoleAttr (unsigned color /*= FOREGROUND_LIGHTGRAY*/)
    {
    unsigned oldAttr = txGetConsoleAttr();

    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), (WORD) color);

    return oldAttr;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txGetConsoleAttr()
    {
    CONSOLE_SCREEN_BUFFER_INFO con = {};
    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);

    return con.wAttributes;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txSetConsoleCursorPos (double x, double y)
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   COORD pos = { (short) ROUND (1.0 * x / fontSz.x + con.srWindow.Left),
                  (short) ROUND (1.0 * y / fontSz.y + con.srWindow.Top ) };

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos) asserted;

$   POINT prev = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return prev;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleCursorPos()
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  pos = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleExtent()
    {
$1  CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  size = { con.srWindow.Right  - con.srWindow.Left + 1,
                    con.srWindow.Bottom - con.srWindow.Top  + 1 };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClearConsole()
    {
$1  HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (out, &con) asserted;

$   COORD start = {con.srWindow.Left, con.srWindow.Top};

$   DWORD len   = (con.srWindow.Right  - con.srWindow.Left + 1) *
                  (con.srWindow.Bottom - con.srWindow.Top  + 1);

$   DWORD written = 0;
$   FillConsoleOutputCharacter (out, 0x20 /*' '*/,    len, start, &written) asserted;
$   FillConsoleOutputAttribute (out, con.wAttributes, len, start, &written) asserted;

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), start) asserted;

$   return written == len;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleFontSize()
    {
$1  Win32::CONSOLE_FONT_INFO font = {0, {8, 16}};

$   _TX_CALL (Win32::GetCurrentConsoleFont, (GetStdHandle (STD_OUTPUT_HANDLE), false, &font));

$   SIZE size = { font.dwFontSize.X, font.dwFontSize.Y };
$   txGDI (Win32::GetTextExtentPoint32 (_txCanvas_BackBuf[1], "W", 1, &size), txDC());

$   POINT sizeFont = { size.cx, size.cy };
$   return sizeFont;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextCursor (bool blink /*= true*/)
    {
$1  bool old = _txConsole_IsBlinking;

$   _txConsole_IsBlinking = blink;

$   return old;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPlaySound (const char filename[] /*= NULL*/, DWORD mode /*= SND_ASYNC*/)
    {
$1  mode |= SND_FILENAME | SND_NODEFAULT | SND_NOWAIT;
$   if (mode & SND_LOOP) mode = (mode & ~SND_SYNC) | SND_ASYNC;

$   if (!filename) mode = SND_PURGE;

$   return !!Win32::PlaySound (filename, NULL, mode);
    }

//-----------------------------------------------------------------------------------------------------------------

int txSpeak (const char* text, ...)
    {
$1  bool verbose = false; (void) verbose;
$   bool async   = false; (void) async;

$   for (; text && *text; text++)
        {
        if      (*text == '\a') {$ async   = true; }
        else if (*text == '\v') {$ verbose = true; }
        else break;
        }

$   char textA [_TX_BUFSIZE] = "You asked to speak empty text. I would rather say that TX Library is cool! Cats rules!";

$   va_list arg; va_start (arg, text);
    if (text && *text) {$ _tx_vsnprintf_s (textA, sizeof (textA) - 1, text, arg); }
$   va_end (arg);

#ifdef TX_USE_SPEAK

    if (text && verbose) {$ printf ("%s", textA); }

$   int time = GetTickCount();

$   static wchar_t textW [_TX_BUFSIZE * sizeof (wchar_t)] = L"";
$   MultiByteToWideChar (_TX_CODEPAGE, 0, textA, -1, textW, sizearr (textW));

$   static ISpVoice* voice = NULL;

$   if (text && !voice)
        {
$       HRESULT res = Win32::CoInitialize (NULL);
        if (res == S_OK) {$ Win32::CoCreateInstance (Win32::CLSID_SpVoice, NULL, CLSCTX_ALL, Win32::IID_ISpVoice, (void**) &voice); }
        }

$   if (text && voice)
        {
$       Win32::_fpreset();
$       voice->Speak (textW, SPF_PERSIST_XML | SPF_PURGEBEFORESPEAK | (async? SPF_ASYNC : 0), NULL);
$       tx_fpreset();
        }

$   if (!text && voice)
        {
$       voice->Release();
$       voice = NULL;

$       Win32::CoUninitialize();
        }

$   return (voice)? GetTickCount() - time : -1;

#else

$   if (text)
        {
$       unsigned oldAttr = txSetConsoleAttr (FOREGROUND_LIGHTRED | BACKGROUND_BLACK);

$       txNotifyIcon (NIIF_ERROR, "txSpeak(): Íå ìîãó ïðîèçíåñòè (íóæåí TX_USE_SPEAK, ñì. TXLib Help)", "\n" "%s", textA);

$       txSetConsoleAttr (oldAttr);
        }

$   return -1;

#endif
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txPlayVideo (int x, int y, int width, int height, const char fileName[],
                      double zoom /*= 0*/, double gain /*= 1*/, HWND wnd /*= txWindow()*/)
    {
$1  if (wnd && wnd == txWindow() && _TX_TXWINDOW_FAILED()) return -1;

$   int time = GetTickCount();

$   static char processUID [64] = "";
    if (!*processUID)
        {
$       FILETIME startTime = {}, null = {};
$       GetProcessTimes (GetCurrentProcess(), &startTime, &null, &null, &null) asserted;
$       _snprintf_s (processUID, sizeof (processUID) - 1, "TXLib[%08X%08X]::txPlayVideo",
                    (unsigned) startTime.dwHighDateTime, (unsigned) startTime.dwLowDateTime) < (int) sizeof (processUID) asserted;
        }

$   if (!fileName)
        {
$       txTaskKill ("vlc.exe", processUID, 0);  // Kill'em all, by command line pattern
$       return 0;
        }

$   static const char* vlcPath = _txPlayVideo_FindVLC();

$   if (!vlcPath || _access (vlcPath, 0) != 0)
        {
$       static int once = false;

$       if (*fileName && !once++)
            {$ txOutputDebugPrintf ("\a" "Íå íàéäåí âèäåîïðîèãðûâàòåëü VideoLAN (vlc.exe). Cêà÷àéòå åãî ñ ñàéòà VideoLAN.org "
                                    "è óñòàíîâèòå. Áåç óñòàíîâêè VideoLAN âèäåî âîñïðîèçâîäèòüñÿ íå áóäåò :(\n\n"
                                    "--\n" "Âñåãäà Âàøà, ôóíêöèÿ " /* êàê áû */ "txPlayVideo()...\n"
                                    "P.S. Ñì. ìîå îïèñàíèå â TXLib Help."); }
$       return INT_MIN;
        }

$   bool async = false;
    if (*fileName == '\a') {$ async = true; fileName++; }

$   RECT rect = {};
    if (wnd) {$ GetClientRect (wnd, &rect); }

    if (!width)  {$ width  = rect.right;  }
    if (!height) {$ height = rect.bottom; }

    // Create a child window to hold the video stream

$   const char* errPos = "ÂÍÅÇÀÏÍÎ";

$   volatile HWND child = NULL;
$   if (wnd && (wnd == txWindow()))
        {
$       const char* wndClass = txRegisterClass ("txPlayVideo", _txPlayVideo_WndProc, 0, NULL_BRUSH, 1);

$       static int number = 1;
$       CREATESTRUCT createData = { NULL, NULL, (HMENU) (size_t) number++, txWindow(), height, width, y, x,
                                    WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, __func__, wndClass };
$       child = txCreateExtraWindow (createData);
$       if (!child)
            {
$           txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                       strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå ìîãó ñîçäàòü îêíî äëÿ âèäåî :("), errPos));
$           return INT_MIN+3;
            }

$       BringWindowToTop (child);

$       wnd = child;
        }

    // Build the command line

    if (!zoom && !wnd) {$ zoom = 1; }

$   char sZoom [64] = "--autoscale";
    if (zoom) {$ _snprintf_s (sZoom, sizeof (sZoom) - 1, "--no-autoscale --zoom=%.10g", zoom) < (int) sizeof (sZoom) asserted; }

$   static char cmd [MAX_PATH*2 + 1024] = "";

$   _snprintf_s (cmd, sizeof (cmd) - 1, "\"%s\" \"%s\" vlc://quit"

                 " %s --gain=%.10g --drawable-hwnd=%" PRIu64 " --video-title=\"%s\" --logfile=%s"

                 " --live-caching=500 --network-caching=500 --quiet-synchro --no-embedded-video --file-logging"

                 " --ignore-config --reset-config --no-one-instance --play-and-exit"
                 " --intf=dummy --dummy-quiet --quiet --no-video-deco --no-video-title-show --no-stats --no-sub-autodetect-file"
                 " --no-disable-screensaver --no-snapshot-preview --no-auto-preparse --no-mouse-events --no-keyboard-events",

                 vlcPath, (*fileName? fileName : "fileName"), sZoom, gain, (uint64_t) wnd, processUID, _txLogName) < (int) sizeof (cmd) asserted;

$   txOutputDebugPrintf ("txPlayVideo (%d, %d, %d, %d, \"%s\", %lg, %lg, %p): [%s]\n\n",
                         x, y, width, height, fileName, zoom, gain, wnd, cmd);
$   if (!*fileName)
        {
        if (child) {$ txDestroyWindow (child); }
$       return (intptr_t) cmd;
        }

$   if (!strstr (fileName, "://") && _access (fileName, 0) != 0)
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå íàéäåí ôàéë \"%s\"", fileName), errPos));

        if (child) {$ txDestroyWindow (child); }
$       return INT_MIN+1;
        }

    // Run VLC, run

$   PROCESS_INFORMATION vlc   = {};
$   STARTUPINFO         start = { sizeof (start) };
$   DWORD               ret   = 0;

$   if (CreateProcess (NULL, cmd, NULL, NULL, true, 0, NULL, NULL, &start, &vlc) &&
        vlc.hProcess && vlc.hThread)
        {
$       if (child)
            {
$           assert (wnd == child);
$           SetWindowLongPtr (wnd, GWLP_USERDATA, (LONG_PTR) vlc.hProcess);
            }

$       if (!async)
            {
$           WaitForSingleObject (vlc.hProcess, INFINITE);
$           GetExitCodeProcess  (vlc.hProcess, &ret) asserted;
            }

$       if (!child)
            {
$           CloseHandle (vlc.hProcess) asserted;
            }

$       CloseHandle (vlc.hThread) asserted;

$       return (async? (intptr_t) wnd : (ret == 0)? time - GetTickCount() : - (int) ret);
        }
    else
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Îøèáêà çàïóñêà VideoLAN (%s)", cmd), errPos));
$       if (child)
            {$ txDestroyWindow (child); }

$       return INT_MIN+4;
        }

    #undef PROCESS_UID_
    }

//-----------------------------------------------------------------------------------------------------------------

inline intptr_t txPlayVideo (const char fileName[], double zoom /*= 0*/, double gain /*= 0*/, HWND wnd /*= txWindow()*/)
    {
$1  return txPlayVideo (0, 0, 0, 0, fileName, zoom, gain, wnd);
    }

//-----------------------------------------------------------------------------------------------------------------

LRESULT CALLBACK _txPlayVideo_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
    const UINT_PTR checkTimer = 1;

    switch (msg)
        {
        case WM_CREATE:
            {
$1          SetTimer  (wnd, checkTimer, 5*_txWindowUpdateInterval, NULL) asserted;
            }
            break;

        case WM_DESTROY:
            {
$1          KillTimer (wnd, checkTimer) asserted;

$           HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

$           if (vlc)
                {
$               Win32::TerminateProcess (vlc, 0);

$               CloseHandle (vlc) asserted;

$               SetWindowLongPtr (wnd, GWLP_USERDATA, 0);
                }
            }
            break;

        case WM_TIMER:
            {
            HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

            if (vlc && WaitForSingleObject (vlc, 0) != WAIT_TIMEOUT)
                {
$1              DestroyWindow (wnd) asserted;
                }
            }
            break;

        default:
            break;
        }

    return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txPlayVideo_FindVLC()
    {
$1  static char vlcPath [MAX_PATH] = "";

$   if (SearchPath (NULL, "vlc.bat", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (SearchPath (NULL, "vlc.exe", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", NULL, vlcPath, sizeof (vlcPath)))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", "InstallDir", vlcPath, sizeof (vlcPath)))
        {
$       strncat_s (vlcPath, sizeof (vlcPath) - 1, "\\vlc.exe", INT_MAX);

        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files"    "\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   return NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// +--<<< Ýòî âðÿä ëè èìååò îòíîøåíèå ê òîìó, ÷òî âû èùåòå :)
// V      Ïîëåçíî ñìîòðåòü íå òîëüêî ââåðõ, íî è âíèç

WNDPROC txSetWindowsHook (WNDPROC wndProc /*= NULL*/)
    {
$1  WNDPROC old = _txAltWndProc; _txAltWndProc = wndProc;
$   return  old;
    }

//-----------------------------------------------------------------------------------------------------------------

//     +--<<< À ýòî, íàêîíåö, èñêîìîå îïðåäåëåíèå ýòîé ôóíêöèè.
//     |      Ñìîòðèòå ïî ñòîðîíàì! Íóæíàÿ âàì ôóíêöèÿ ãäå-òî ðÿäîì.
//     |
//     v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()
    {
    txMessageBox ("Ýòî çàïëàíèðîâàííàÿ îøèáêà. Òàêîå áûâàåò. Âû õîòåëè âûçâàòü:\n\n"

                  "txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()\n\n"

                  "Õîòü âû äîëãî [êîïèðîâàëè]íàáèðàëè ýòî èìÿ, íà ñàìîì äåëå ýòà ôóíêöèÿ íå ðåàëèçîâàíà. "
                  "Åñòü äðóãàÿ ôóíêöèÿ, êîòîðàÿ óáèðàåò àâòî-ïàóçó â êîíöå ïðîãðàììû, íî â õåëïå ïðî íåå íå íàïèñàíî.\n\n"

                  "Íî íå âñå òàê ïëîõî. Îïðåäåëåíèå íóæíîé ôóíêöèè åñòü â èñõîäíûõ òåêñòàõ TXLib.h, îíî ëåæèò ðÿäîì "
                  "ñ îïðåäåëåíèåì òîé ôóíêöèè ñ äëèííûì íàçâàíèåì, êîòîðóþ âû ñåé÷àñ âûçâàëè.\n\n"

                  "Íàæìèòå â ðåäàêòîðå Ctrl+O, íàéäèòå è îòêðîéòå ôàéë TXLib.h (îí ëåæèò â ïàïêå, êóäà âû "
                  "óñòàíîâèëè TXLib), çàòåì íàæìèòå Ctrl+F è èùèòå \"txIDontWant\". Óäà÷è!\n\n",

                  "Íå ïîëó÷èëîñü", MB_ICONSTOP);

    // The truth is out there... (C++files)

    return false;
    }

//-----------------------------------------------------------------------------------------------------------------

// Bingo! Now you are learned to use the Sources, Luke. And may the Source be with you.

inline bool txDisableAutoPause()
    {
    _txExit = true;
    return true;
    }

// P.S. This library contains more undocumented functions. Search them via "Luke" keyword.

//-----------------------------------------------------------------------------------------------------------------

void _txDump (const void* address, const char name[] /*= "_txDump()"*/, bool pause /*= true*/)
    {
$1  assert (!_txIsBadReadPtr (address));

    const unsigned char* p = (const unsigned char*) address;
$   unsigned x = 0;

$   unsigned attr = txGetConsoleAttr();

$   txSetConsoleAttr (FOREGROUND_WHITE);
$   printf ("\n%*.*s ", (int) sizeof (address) * 2, (int) sizeof (address) * 2, ((name)? name : ""));

$   txSetConsoleAttr (FOREGROUND_YELLOW);
$   for (x = 0; x < 16; x++) printf ("%02X ", x);
$   for (x = 0; x < 16; x++) printf ("%X",    x);

$   const char   isCtrl[] = "\a" "\b" "\n" "\r" "\t" "\0";
$   const char   xlatCh[] =  "·"  "·"  "·"  "·"  "·"  "·";
$   const size_t szCtrl   = sizeof (isCtrl) - 1;

$   int oldCP = GetConsoleOutputCP();

$   for (int y = 0; y < 16; y++, p += 16)
        {
        txSetConsoleAttr (FOREGROUND_YELLOW);

        printf ("\n" "%*p ", (int) sizeof (address) * 2, p);

        int color = FOREGROUND_LIGHTGREEN;

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);
            printf ("%02X ", p[x]);
            }

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);

            char c = p[x];
            const char* ctrl = (const char*) memchr (isCtrl, c, szCtrl);
            if (ctrl) c = xlatCh [ctrl - isCtrl];

            if (ctrl) SetConsoleOutputCP (1251);

            printf ("%c", c);

            if (ctrl) SetConsoleOutputCP (oldCP);
            }
        }

$   txSetConsoleAttr (attr);
$   printf ("\n");

$   if (pause)
        {
$       SetConsoleOutputCP (_TX_CODEPAGE);

$       fprintf (stderr, "[Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]                          CodePage = %5d\n", oldCP);
$       (void)_getch();

$       SetConsoleOutputCP (oldCP);
        }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txStackBackTrace (const char file[] /*= "?"*/, int line /*= 0*/, const char func[] /*= "?"*/,
                        bool readSource /*= true*/)
    {
$1  unsigned attr = txGetConsoleAttr();
$   txSetConsoleAttr (FOREGROUND_LIGHTCYAN);

$   fprintf (stderr, "\n" "--------------------------------------------------\n"
                          "Òðàññèðîâêà ñòåêà èç \"%s\" at %s (%d):\n\n"
                          "%s\n\n"
                          "--------------------------------------------------\n\n",
                          func, file, line, _txCaptureStackBackTrace (1, readSource));

$   txSetConsoleAttr (attr);
    }

//-----------------------------------------------------------------------------------------------------------------

char* txDemangle (const char* mangledName, std::nomeow_t)
    {
$1  if (!mangledName) return NULL;

$   char* typeName = NULL;

    #if defined (_GCC_VER)

$   int err = 1;
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err); (void) err;
    if (typeName) {$ return typeName; }

    #endif

$   unsigned short flags = 0;

$   if (mangledName[0] == '.')
        {
$       mangledName++;
$       flags = 0x2800;  // UNDNAME_32_BIT_DECODE | UNDNAME_TYPE_ONLY
        }

$   typeName = _TX_CALL (Win32::__unDName, (NULL, mangledName, 0, malloc, free, flags));
    if (typeName) {$ return typeName; }

$   return _strdup (mangledName);
    }

//-----------------------------------------------------------------------------------------------------------------

std::string txDemangle (const char* mangledName)
    {
$1  char* typeName = txDemangle (mangledName, std::nomeow);
$   std::string name (typeName? typeName : "");
$   free (typeName);

$   return name;
    }

//-----------------------------------------------------------------------------------------------------------------

double txQueryPerformance()
    {
$1  int maxTime    =  500;
$   int maxSamples =  100;
$   POINT size     = {100, 100};

$   HDC dc = _txBuffer_Create (txWindow(), &size, NULL);
$   assert (dc); if (!dc) return -1;

$   DWORD mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), 1);
$   assert (mask);

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   int samples = 0;
$   while (samples++ < maxSamples)
        {
$       LARGE_INTEGER cur = {};
$       QueryPerformanceCounter (&cur) asserted;

$       double t = 1000.0 * (double) (cur.QuadPart - start.QuadPart) / (double) freq.QuadPart;
$       if (t > maxTime) break;

        // Draw test scene

$       for (int y = 0; y < size.y; y++)
        for (int x = 0; x < size.x; x++)     txSetPixel (x, y, TX_BLACK, dc);

$       for (int y = 0; y < size.y; y += 10)
        for (int x = 0; x < size.x; x += 50) txTextOut  (x, y, "*", dc);

$       txEllipse (0, 0, size.x, size.y, dc);
$       txFloodFill (size.x/2, size.y/2, TX_TRANSPARENT, FLOODFILLSURFACE, dc);

$       txBitBlt (dc, size.x/2,        0, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc,        0, size.y/2) asserted;
$       txBitBlt (dc,        0, size.y/2, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, size.x/2,        0) asserted;
        }

$   mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), mask);
$   assert (mask);

$   _txBuffer_Delete (&dc);

$   return 3.0 * samples / sqrt (1.0 * size.x * size.y);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_TX_CPP11)
template <int txFramesToAverage>
#endif

double txGetFPS (int minFrames)
    {
$1  static LARGE_INTEGER time0 = {}; if (!time0.QuadPart) QueryPerformanceCounter (&time0);
$          LARGE_INTEGER time  = {};                      QueryPerformanceCounter (&time);

$   if (time.QuadPart - time0.QuadPart == 0)
        {$ return 0; }

$   LARGE_INTEGER freq = {}; QueryPerformanceFrequency (&freq);

$   double fps = (double) freq.QuadPart / (double) (time.QuadPart - time0.QuadPart);
$   time0 = time;

$   if (txFramesToAverage == 0) return fps;

$   static double average [txFramesToAverage] = {};
$   static unsigned n = 0;

$   average [n++ % txFramesToAverage] = fps;

$   unsigned nn = MIN (n, (unsigned) sizearr (average));

$   static double median  [txFramesToAverage] = {};
$   std::copy (average, average + nn, median);
$   std::nth_element (median, median + nn/2, median + nn);

$   fps = (median [(nn-1) / 2] + median [nn / 2]) / 2.0;

$   return ((int)n >= MIN (minFrames, txFramesToAverage))? fps : 0;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txExtractColor (COLORREF color, COLORREF component)
    {
$1  switch (component)
        {
        case TX_RED:
        case TX_HUE:        $ return (color >>  0) & 0xFF;

        case TX_GREEN:
        case TX_SATURATION: $ return (color >>  8) & 0xFF;

        case TX_BLUE:
        case TX_LIGHTNESS:  $ return (color >> 16) & 0xFF;

        default:            $ return CLR_INVALID;
        }
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txRGB2HSL (COLORREF rgbColor)
    {
$1  int r = (int) txExtractColor (rgbColor, TX_RED),
        g = (int) txExtractColor (rgbColor, TX_GREEN),
        b = (int) txExtractColor (rgbColor, TX_BLUE);

$   double m1 = MAX (MAX (r, g), b) / 255.0,
           m2 = MIN (MIN (r, g), b) / 255.0,
           dm = m1 - m2,
           sm = m1 + m2,

           ir = r / 255.0,
           ig = g / 255.0,
           ib = b / 255.0,

           ih = 0,
           is = 0,
           il = sm / 2;

$   const double prec = 0.001;

$   if (fabs (dm) < prec)
        {
$       is = dm / ((sm <= 1)? sm : (2-sm));

$       double cr = (m1 - ir) / dm,
               cg = (m1 - ig) / dm,
               cb = (m1 - ib) / dm;

$       if (fabs (ir - m1) < prec) ih =     cb - cg;
$       if (fabs (ig - m1) < prec) ih = 2 + cr - cb;
$       if (fabs (ib - m1) < prec) ih = 4 + cg - cr;
        }

$   ih = (ih >= 0)? ih*60 : ih*60 + 360;

$   return RGB (ROUND (ih / 360 * 255), ROUND (is * 255), ROUND (il * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txHSL2RGB (COLORREF hslColor)
    {
$1  struct xRGB
        {
        static double calc (double h, double m1, double m2)
            {
$           if (h < 0)   h += 360;
$           if (h > 360) h -= 360;

$           return (h <  60)? m1 + (m2-m1) *      h  / 60 :
                   (h < 180)? m2 :
                   (h < 240)? m1 + (m2-m1) * (240-h) / 60 :
                              m1;
            }
        };

$   int h = (int) txExtractColor (hslColor, TX_HUE),
        s = (int) txExtractColor (hslColor, TX_SATURATION),
        l = (int) txExtractColor (hslColor, TX_LIGHTNESS);

$   double ih = h / 255.0 * 360.0,
           il = l / 100.0,
           is = s / 100.0,

           m2 = (il <= 0.5)? il * (1 + is) : il + is - il * is,
           m1 = 2 * il - m2,

           ir = s? xRGB::calc (ih + 120, m1, m2) : il,
           ig = s? xRGB::calc (ih,       m1, m2) : il,
           ib = s? xRGB::calc (ih - 120, m1, m2) : il;

$   return RGB (ROUND (ir * 255), ROUND (ig * 255), ROUND (ib * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (std::nomeow_t, double left, double right)
    {
    return left + (right - left) * ((double) rand() / RAND_MAX);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (std::nomeow_t, Tx x, Ta a, Tb b)
    {
    return a <= x && x <= b;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int random (int range)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return rand() % range;
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (double left, double right)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return random (std::nomeow, left, right);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (Tx x, Ta a, Tb b)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return In (std::nomeow, x, a, b);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const POINT& pt, const RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.x, rect.left, rect.right) &&
           In (std::nomeow, pt.y, rect.top,  rect.bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const COORD& pt, const SMALL_RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.X, rect.Left, rect.Right) &&
           In (std::nomeow, pt.Y, rect.Top,  rect.Bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

void tx_fpreset()
    {
$1  txAutoLock _lock;

$   Win32::_fpreset();

$   unsigned new87 = 0x0008001C;  // _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW

    #if !defined (__CYGWIN__)

$   unsigned old87 = 0;
$   if (_controlfp_s (&old87, 0, 0) == 0)
        {$ (void) _controlfp_s (&old87, old87  & ~new87, 0x0008001F); }  // _MCW_EM

    #else

$   Win32::_controlfp (Win32::_controlfp (0, 0) & ~new87, 0x0008001F);    // _MCW_EM

    #endif
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T zero() { T __zero = {}; return __zero; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txPrintf() implementation
//           Ðåàëèçàöèÿ txPrintf()
//=================================================================================================================

#if defined (_TX_CPP11)

template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                                  const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width,                   const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                precision_t prec, const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args);
                                         void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt);

template <typename T>                    void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int*     arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt);

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg, ArgsT... args)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*') {$ stream << std::setw (width); }
    else {$ TX_ERROR ("\"%%*\" required to setwidth (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '*') {$ stream << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%.*\" required to setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*' && fmt[2] == '.' && fmt[3] == '*') {$ stream << std::setw (width) << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%*.*\" required to setwidth (%d) and setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (!fmt[0]) {$}
    else {$ TX_ERROR ("No argument provided for %% in \"%s\" while printing \"%s\"", fmt, format); }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char*, int, const char*& fmt)
    {
$1  assert (&stream);
$   assert (fmt);

$   while (*fmt)
        {
        if (fmt[0] == '%')
            {
            if (fmt[1] == '%') fmt++;
            else break;
            }

        stream << *fmt++;
        }
$   }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg)
    {
$1  assert (&stream);
$   assert (fmt);

$   if (_TX_ARGUMENT_FAILED (&arg)) return;

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   fmt++;

$   char                    oldFill  = stream.fill (' ');
$   std::ios_base::fmtflags oldFlags = stream.flags();

$   for (;;) switch (*fmt)
        {
        case '-': $ stream << std::left;     fmt++; break;
        case '+': $ stream << std::showpos;  fmt++; break;
        case ' ': $ stream.fill (' ');       fmt++; break;
        case '#': $ stream << std::showbase; fmt++; break;
        case '0': $ stream.fill ('0');       fmt++; break;

        default:  $ goto end;
        }
    end:

$   int width = (*fmt != '*')?                  (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0);
$   int prec  = (*fmt == '.')? (*++fmt != '*')? (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0) : 0;

    if (width) {$ stream << std::setw (width);        }
    if (prec)  {$ stream << std::setprecision (prec); }

$   fmt += strspn (fmt, "hljztL");

$   switch (*fmt)
        {
        case '$':
        case '?': $                                              break;

        case 'd':
        case 'i':
        case 'u': $ stream << std::dec;                          break;

        case 'o': $ stream << std::oct;                          break;

        case 'x': $ stream << std::hex;                          break;
        case 'X': $ stream << std::hex        << std::uppercase; break;

        case 'f': $ stream << std::fixed;                        break;
        case 'F': $ stream << std::fixed      << std::uppercase; break;

        case 'e': $ stream << std::scientific;                   break;
        case 'E': $ stream << std::scientific << std::uppercase; break;

        case 'g': $                                              break;
        case 'G': $ stream                    << std::uppercase; break;

        case 'a': $                                              break;
        case 'A': $ stream                    << std::uppercase; break;

        case 'c':
        case 's':
        case 'p': $                                              break;

        default:  $ TX_ERROR ("Invalid format '%.1s' at \"%s\" while printing %s argument %d in \"%s\"", fmt, fmt, txTypename (arg), n, format); break;
        }

$   fmt++;

    if (&arg) {$ stream << arg;      }
    else      {$ stream << "(null)"; }

$   stream.fill  (oldFill);
$   stream.flags (oldFlags);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int* arg)
    {
$1  assert (fmt);

    if (_TX_ARGUMENT_FAILED (arg)) return;

    if (fmt[0] == '%' && fmt[1] == 'n') {$}
    else {$ TX_ERROR ("\"%%n\" required to store print length in int* argument %d in \"%s\"", n, format); }

$   *arg = (int) stream.str().length();

$   fmt += 2;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T> inline const T&    _txPrintfNormalizeArg (const T&           arg) { if (_TX_ARGUMENT_FAILED (&arg)) {;}          return arg;         }
                      inline const char* _txPrintfNormalizeArg (const std::string& arg) { if (_TX_ARGUMENT_FAILED (&arg)) return NULL; return arg.c_str(); }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (std::ostringstream& stream, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&stream)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   const char* fmt = format;
$   _txPrintF (stream, format, 2, fmt, _txPrintfNormalizeArg (args)...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (char buffer[], size_t size, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&buffer)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   if (size > 0) size--;
$   buffer[size] = 0;

$   if (!size) return 0;

$   std::ostringstream stream;
$   stream.rdbuf() -> pubsetbuf (buffer, size);

$   txPrintf (stream, format, args...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline std::string txFormat (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return "";

$   std::ostringstream stream;

$   txPrintf (stream, format, args...);

$   return stream.str();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   return printf ("%s", txFormat (format, args...) .c_str());
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

       int _txPrintfCheck (const char* format, ...) tx_printfy (1);
inline int _txPrintfCheck (const char*,        ...) { return 0; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txDialog methods implementation
//           Ðåàëèçàöèÿ ìåòîäîâ êëàññà txDialog
//
//           See [1] http://msdn.microsoft.com/ru-ru/library/windows/desktop/ms645389%28v=vs.85%29.aspx
//               [2] http://blogs.msdn.microsoft.com/oldnewthing/20050429-00/?p=35743
//               [3] http://blogs.msdn.microsoft.com/oldnewthing/20040623-00/?p=38753
//=================================================================================================================

txDialog::txDialog () :
    layout_ (NULL)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

txDialog::txDialog (const Layout* layout) :
    layout_ (layout)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

const txDialog::Layout* txDialog::setLayout (const Layout* layout)
    {
$1  assert (layout);

$   return ::std::swap (layout_, layout), layout;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (WORD resourceID)
    {
$1  const char* resName = (char*)(uintptr_t) resourceID;

$   if (!FindResource (NULL, resName, RT_DIALOG)) return TX_DEBUG_ERROR ("Íå íàéäåí ðåñóðñ äèàëîãà %d", resourceID), 0;

$   return DialogBoxParam (NULL, resName, NULL, (DLGPROC) DialogProc_, (LPARAM) this);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (const txDialog::Layout* layout /*= NULL*/, size_t bufsize /*= 0*/)
    {
$1  if (!layout)  layout = layout_;
$   if (!layout)  return TX_DEBUG_ERROR ("Íå óñòàíîâëåí äèíàìè÷åñêèé øàáëîí äèàëîãà"), 0;

$   if (!bufsize) bufsize = 1024;

$   DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$   if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà"), 0;

$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };

$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];

$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }

$   tmpl->cdit = (unsigned short) (i-1);

$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);

$   GlobalFree (tmpl);

$   return res;
    }

//-----------------------------------------------------------------------------------------------------------------

int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;

        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;

            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }

$   return FALSE;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;

$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;

$   WORD* pw = (WORD*) globalMem;

$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;

$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }

$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   return pw;
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;

$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;

$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;

$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }

$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }

$   *pw++ = 0;

$   return pw;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================

#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$

//}
//=================================================================================================================

//! @endcond

//=================================================================================================================
//{          Experimental Debugging macros
//! @name    Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//!          âî âðåìÿ åãî âûïîëíåíèÿ.
//!
//!          Ñäåëàé ïðèÿòíûìè òâîè <i>êðóãëûå ñóòêè : "ÂÍÅÇÀÏÍÎ"),
               VPRINT_ (msg, args);
 
    while (s > what && s[-1] == '\n') s--;
 
                PRINT_ ("\n\n" "#%d: %s, Instance: 0x%p (%d-bit), Flags: %c%c%c%c%c%d, Thread: 0x%X%s",
 
                        _txErrors, _TX_VERSION, &_txInitialized, (sizeof (void*) == 4)? 32 : 64,
 
                        "cC"[_txConsole], "mM"[_txMain], "dD"[_txIsDll], "rR"[_txRunning], "eE"[_txExit], _txLoc::Cur.trace,
 
                        threadId, (threadId == _txMainThreadId)?    " (Main)"   :
                                  (threadId == _txCanvas_ThreadId)? " (Canvas)" : "");
 
    if (winErr) PRINT_ (", GetLastError(): %lu (", (unsigned long) winErr),
                s += FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                                    NULL, winErr, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                                    s, (DWORD) (sizeof (what) - (s-what)), NULL) - 2,
                s -=  (s[-1] == '.')? 1 : 0,
                PRINT_ (")");
 
    if (crtErr) PRINT_ (", errno: %d (%s)",        crtErr, (strerror_s (str, sizeof (str), crtErr), str));
    if (dosErr) PRINT_ (", _doserrno: %lu (%s)",   dosErr, (strerror_s (str, sizeof (str), dosErr), str));
    if (oglErr) PRINT_ (", glGetError(): %u (0x%04X, %s)", oglErr, oglErr, _TX_CALL (Win32::gluErrorString, (oglErr)));
 
    #if (__cplusplus <= 201703L)
                PRINT_ (". %s\n", ::std::uncaught_exception ()? "std::uncaught_exception(): true."  : "");
    #else
                PRINT_ (". %s\n", ::std::uncaught_exceptions()? "std::uncaught_exceptions(): true." : "");
    #endif
 
    if (_txLoc::Cur.inTX > 0 && file && !(_txLoc::Cur.line == line && _stricmp (_txLoc::Cur.file, file) == 0) &&
       (_txLoc::Cur.file || _txLoc::Cur.line || _txLoc::Cur.func))
                PRINT_ ("From: %s (%d) %s.\n", _txLoc::Cur.file, _txLoc::Cur.line, _txLoc::Cur.func);
 
    txOutputDebugPrintf ("\r" "%s - ERROR: %s\n", _TX_VERSION, what);
 
    if (options & fmtOnly)
        {
        SetLastError (winErr);
 
        errno = crtErr;
 
        #if !defined (__CYGWIN__)
        _doserrno = dosErr;
        #endif
 
        return what;
        }
 
    unsigned restore = txGetConsoleAttr();
    txSetConsoleAttr ((options & isFatal)? FOREGROUND_LIGHTMAGENTA : FOREGROUND_LIGHTRED);
    if (color) {$ txSetConsoleAttr (color); }
 
    int oldCodePage = txSetLocale();
 
    fprintf (stderr,      "\n" "--------------------------------------------------\n"
                               "%s\n"
                               "--------------------------------------------------\n",
                               what);
 
    if (stkTrace && strstr (stkTrace, ".exe: "))
        {$ fprintf (stderr,    "Ñòåê âûçîâîâ:\n\n"
                               "%s\n\n"
                               "--------------------------------------------------\n",
                               stkTrace); }
 
    SetConsoleOutputCP (oldCodePage);
    txSetConsoleAttr (restore);
 
    if (*_txLogName) do
        {
        FILE* log = NULL; fopen_s (&log, _txLogName, "a");
        if (!log) {$ break; }
 
        fprintf (log,     "\n" "--------------------------------------------------\n"
                               "%s\n"
                               "--------------------------------------------------\n",
                               what);
 
        fprintf (log,          "Ñòåê âûçîâîâ:\n\n"
                               "%s\n",
                               (*_txTraceSE? _txTraceSE : stkTrace));
 
        #if defined (_TX_ALLOW_TRACE) || defined (_DEBUG)
 
        if (_txLoc::Cur.inTX > 0 && txTrace && *txTrace)
            {
            fprintf (log, "\n" "--------------------------------------------------\n"
                               "Ñòåê âûçîâîâ TX:\n\n"
                               "%s\n",
                               txTrace);
            }
 
        #endif
 
        fprintf (log,     "\n" "--------------------------------------------------\n"
                               "%s\n\n"
                               "--------------------------------------------------\n",
                               _txAppInfo());
        fclose (log);
        break;
        }
        while (false);
 
    int ret = 0;
 
    if (!(options & noMsgBox))
        {
        txSleep (_txWindowUpdateInterval);
 
        PRINT_ ("\n" "Ïðåðâàòü ïðîãðàììó?");
 
        ret = txMessageBox (what, ((options & isWarning)? "Ïðåäóïðåæäåíèå"   :
                                   (options & isFatal)?   "Ôàòàëüíàÿ îøèáêà" :
                                                          "Îøèáêà â ïðîãðàììå), MB_ICONSTOP | MB_SYSTEMMODAL | MB_YESNOCANCEL);
        }

    SetLastError (winErr);

    errno = crtErr;

    #if !defined (__CYGWIN__)
    _doserrno = dosErr;
    #endif

    if (((options & isFatal) && !IsDebuggerPresent()) || ret == IDYES)
        {
        txUnlock();
        _txCleanup();
        Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
        }

    #undef PRINT_

    return what;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_MSC_VER)

int _txOnErrorReport (int type, const char* text, int* ret)
    {
    assert (text);
    assert (ret);

    _txErrors++;

    unsigned restore = txGetConsoleAttr();

    switch (type)
       {
       case _CRT_WARN:   txSetConsoleAttr (FOREGROUND_LIGHTRED);     break;
       case _CRT_ERROR:  txSetConsoleAttr (FOREGROUND_LIGHTMAGENTA); break;
       case _CRT_ASSERT: txSetConsoleAttr (FOREGROUND_YELLOW);       break;
       default:                                                      break;
       }

    const char startReport[] = "Detected memory leaks!\n",
                 endReport[] = "Object dump complete.\n";

    if (strcmp (text, startReport) == 0)  // Dirty, dirty hack. À ÷òî äåëàòü?
        {
        _txOnErrorReport (type, "\n",                                                                              NULL);
        _txOnErrorReport (type, _TX_VERSION " - ERROR: ",                                                          NULL);
        _txOnErrorReport (type, "Âíèìàíèå: Îáíàðóæåíû óòå÷êè ïàìÿòè! (Äëÿ ïîèñêà èñïîëüçóéòå _TX_ALLOC_BREAK.)\n", NULL);
        _txOnErrorReport (type, "\n",                                                                              NULL);
        }

    size_t len = strlen (text);
    if (text [len-1] != '\n')               txOutputDebugPrintf ("%s",                text);
    else if (strcmp (text, endReport) != 0) txOutputDebugPrintf ("%s" "%s - ERROR: ", text, _TX_VERSION);
    else                                    txOutputDebugPrintf ("%s\n",              text);

    DWORD n = 0;
    HANDLE err = GetStdHandle (STD_ERROR_HANDLE);
    WriteFile (err, text, (DWORD) strlen (text), &n, NULL);

    txSetConsoleAttr (restore);

    if (*_txLogName) do
        {
        HANDLE log = CreateFile (_txLogName, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (log == INVALID_HANDLE_VALUE) break;

        SetFilePointer (log, 0, NULL, FILE_END);
        WriteFile (log, text, (DWORD) strlen (text), &n, NULL);

        CloseHandle (log);
        break;
        }
        while (false);

    if (ret) *ret = 0;

    return (type == _CRT_WARN);
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

int txMessageBox (const char text[], const char header[], unsigned flags /*= MB_ICONINFORMATION | MB_OKCANCEL*/)
    {
$5  static wchar_t textW   [_TX_BIGBUFSIZE * sizeof (wchar_t)] = L"[NULL text]";
$   static wchar_t headerW [_TX_BUFSIZE    * sizeof (wchar_t)] = L"[NULL header]";

    if (text)   {$ MultiByteToWideChar (_TX_CODEPAGE, 0, text,   -1, textW,   sizearr (textW))   || memset (textW,   0, sizeof (textW));   }
    if (header) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, header, -1, headerW, sizearr (headerW)) || memset (headerW, 0, sizeof (headerW)); }

$   HWND wnd = _txCanvas_Window;
$   int  ret = MessageBoxW ((wnd && IsWindowVisible (wnd))? wnd : _TX_CALL (Win32::GetConsoleWindow,()),
                            textW, headerW, flags | MB_SETFOREGROUND | MB_TOPMOST | MB_OKCANCEL );
$   if (ret == IDCANCEL)
        {
$       SendNotifyMessage (txWindow(), (_txMain? WM_CLOSE : WM_DESTROY), 0, 0);
$       _txWaitFor (!_txCanvas_Window, _TX_TIMEOUT);
        }

$   return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txGetAsyncKeyState (int key)
    {
$1  HWND wnd = GetForegroundWindow();

    return (GetAsyncKeyState (key) & 0x8000) &&
           (wnd == txWindow() || wnd == Win32::GetConsoleWindow());
    }

//-----------------------------------------------------------------------------------------------------------------

bool txNotifyIcon (unsigned flags, const char title[], const char format[], ...)
    {
$5  if (_TX_ARGUMENT_FAILED (format)) return false;

$   va_list arg; va_start (arg, format);
$   bool ok = true;

    #if defined (_WIN32_IE) && (_WIN32_IE >= 0x0500)

$   NOTIFYICONDATA nid = { sizeof (nid) };

$   nid.uFlags      = NIF_ICON | NIF_TIP | NIF_INFO;
$   nid.hWnd        = NULL;
$   nid.uID         = 1;
$   nid.hIcon       = _txCreateTXIcon (16); assert (nid.hIcon);
$   strncpy_s       (nid.szTip,       sizeof (nid.szTip),       "TXLib Information", sizeof (nid.szTip));
$   strncpy_s       (nid.szInfoTitle, sizeof (nid.szInfoTitle), (title? title : "TXLib ñîîáùàåò"), sizeof (nid.szInfoTitle) - 1);
$   _tx_vsnprintf_s (nid.szInfo, sizeof (nid.szInfo), format, arg);
$   nid.dwInfoFlags = flags;

$   txOutputDebugPrintf ("\r" _TX_VERSION " - %s: %s (Icon notification)\n", nid.szInfoTitle, nid.szInfo);

$   ok &= !!Shell_NotifyIcon (NIM_ADD,    (::NOTIFYICONDATA*) &nid);
$   ok &= !!Shell_NotifyIcon (NIM_MODIFY, (::NOTIFYICONDATA*) &nid);

$   if (nid.hIcon) DestroyIcon (nid.hIcon) asserted;

    #else

$   char nid_szInfo[_TX_BUFSIZE] = "";
$   _tx_vsnprintf_s (nid_szInfo, sizeof (nid_szInfo), format, arg);
$   txOutputDebugPrintf ("\r" _TX_VERSION " - %s: %s (Icon notification - NOT displayed)\n", title, nid_szInfo);
$   ok = false;

$   (void)flags; (void)title;

    #endif

$   va_end (arg);
    return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

void _txTrace (const char file[], int line, const char func[], const char msg[] /*= NULL*/, ...)
    {
    unsigned id = GetCurrentThreadId();

    const char marks[2][2][3] = {{"uU", "cC"}, {"mM", "??"}};

    char mark = marks [id == _txMainThreadId] [id == _txCanvas_ThreadId] [(_txLoc::Cur.inTX > 0)];

    char msgStr[_TX_BUFSIZE] = "";
    if (msg)
        {
        va_list arg; va_start (arg, msg);
        _tx_vsnprintf_s (msgStr, sizeof (msgStr) - 1, msg, arg);
        va_end (arg);
        }

    txOutputDebugPrintf ("%s - 0x%p %c%c%c%c%c%d [%c] - %-*s (%5d)  " "|%*s%s" "%s%s\n",

                         _TX_VERSION, &_txInitialized,

                         "cC"[_txConsole], "mM"[_txMain], "dD"[_txIsDll], "rR"[_txRunning], "eE"[_txExit],
                         _txLoc::Cur.trace, mark,

                         (int) sizeof (__FILE__) - 1, (file? file : "(NULL file)"), line,
                         2 * (_txLoc::Cur.inTX - 1) * !!func, "", (func? func : ""),

                         ((*msgStr && func)? ": " : ""), msgStr);
    }

//-----------------------------------------------------------------------------------------------------------------

int txOutputDebugPrintf (const char format[], ...)
    {
    if (!format) return 0;

    enum { msgbox = 1, print = 2, compr = 4 };
    int options = 0;

    for (; format && *format; format++)
        {
        if      (*format == '\a') options |= msgbox;
        else if (*format == '\f') options |= print;
        else if (*format == '\r') options |= compr;
        else break;
        }

    char text[_TX_BIGBUFSIZE] = "";

    va_list arg; va_start (arg, format);
    int n = (int) _tx_vsnprintf_s (text, sizeof (text) - 1-1, format, arg);
    va_end (arg);

    struct __ { static int trimSpaces (char str[])
        {
        char *dst = str, *src = str;

        for (char d = ' '; d; src++)
            if (isspace ((unsigned char)(*src))) { if (d != ' ') *dst++ = d = ' '; }
            else                                                 *dst++ = d = *src;

        return (int) (dst - str - 1);
        }};

    if (options & compr)  n = __::trimSpaces (text);

    OutputDebugString (text);

    if (options & print)  fprintf (stderr, "%s", text);

    if (options & msgbox) txMessageBox (text, "Îêàçûâàåòñÿ, ÷òî", MB_ICONEXCLAMATION);

    return n;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _tx_snprintf_s (char stream[], intptr_t size, const char format[], ...)
    {
    if (!format) return 0;

    va_list arg; va_start (arg, format);
    intptr_t ret = _tx_vsnprintf_s (stream, size, format, arg);
    va_end (arg);

    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _tx_vsnprintf_s (char stream[], intptr_t size, const char format[], va_list arg)
    {
    if (!stream || !format) return 0;

    #if defined (_TRUNCATE)
    intptr_t ret = _vsnprintf_s (stream, size, _TRUNCATE, format, arg);
    #else
    intptr_t ret = _vsnprintf   (stream, size,            format, arg);
    #endif

    if (ret < 0 && size >= 4)
        {
        const char ellipsis[] = "...";
        size_t     szEllipsis = sizeof (ellipsis) - 1;

        strncpy_s (stream + size - szEllipsis, szEllipsis+1, ellipsis, szEllipsis);
        }

    return (ret >= 0)? ret : size;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (__CYGWIN__)

int _getch()
    {
    termios oldattr = {}; tcgetattr (STDIN_FILENO, &oldattr);

    termios newattr = oldattr;
    newattr.c_lflag &= ~(ICANON | ECHO);
    tcsetattr (STDIN_FILENO, TCSANOW, &newattr);

    int ch = getchar();

    tcsetattr (STDIN_FILENO, TCSANOW, &oldattr);

    return ch;
    }

//-----------------------------------------------------------------------------------------------------------------

int _putch (int ch)
    {
    termios old = {}; tcgetattr (STDOUT_FILENO, &old);

    termios cur = old;
    cur.c_lflag &= ~ICANON;
    cur.c_lflag |=  ECHO;
    tcsetattr (STDOUT_FILENO, TCSANOW, &cur);

    putchar (ch);

    tcsetattr (STDOUT_FILENO, TCSANOW, &old);

    return ch;
    }

//-----------------------------------------------------------------------------------------------------------------

int _kbhit()
    {
    termios old = {}; tcgetattr (STDIN_FILENO, &old);

    termios cur = old;
    cur.c_lflag &= ~(ICANON | ECHO);
    cur.c_cc[VMIN]  = 1;
    cur.c_cc[VTIME] = 0;

    tcsetattr (STDIN_FILENO, TCSAFLUSH, &cur);

    fd_set  fd = {}; FD_SET (STDIN_FILENO, &fd);
    timeval tv = {};

    int res = select (STDIN_FILENO + 1, &fd, NULL, NULL, &tv) && FD_ISSET (STDIN_FILENO, &fd);

    tcsetattr (STDIN_FILENO, TCSAFLUSH, &old);

    return res;
    }

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Information
//-----------------------------------------------------------------------------------------------------------------

const char* txGetModuleFileName (bool fileNameOnly /*= true*/)
    {
    static char name[MAX_PATH] = "";

    if (!*name)
        {
        if (!GetModuleFileName (NULL, name, sizeof (name) - 1)) *name = 0;

        char* ext = strrchr (name, '.');
        if (ext) _strlwr_s (ext, sizeof (name) - 1 - (ext - name));
        }

    assert (*name);

    if (fileNameOnly) return name;

    static char fullName[MAX_PATH] = "";
    strncpy_s (fullName, sizeof (fullName), name, sizeof (fullName) - 1);

    char* title = strrchr (fullName, '\\'); if (!title) title = fullName;
    char* ext   = strrchr (fullName,  '.'); if (!ext)   ext   = fullName + strlen (fullName);

    size_t sz = sizeof (fullName) - (ext - fullName);
    strncpy_s (ext, sz-1, " - TXLib", sz);

    return title + 1;
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txAppInfo()
    {
$1  time_t timeT     = time (NULL) - clock()/CLOCKS_PER_SEC;
    char   timeS[32] = "";
    ctime_s (timeS, sizeof (timeS), &timeT);

    static char text[_TX_BUFSIZE] = "";
    char cwd [MAX_PATH] = "";

    _tx_snprintf_s (text, sizeof (text) - 1,

                    "Developed with:\n\n"
                    "The Dumb Artist Library (TX Library)\n"
                    _TX_VERSION "\n" _TX_AUTHOR "\n"
                    "See license on: http://txlib.ru\n\n"

                    "TXLib file:" "\t" __FILE__ "\n"
                    "Compiled:"   "\t" __DATE__ " " __TIME__ ", " __TX_COMPILER__ ", %s, %d-bit, " _TX_BUILDMODE "\n"
                    "Started:"    "\t" "%.6s %.4s %.8s\n\n"

                    "Run file:"   "\t" "%s\n"
                    "Directory:"  "\t" "%s",

    #if   defined (_MSC_VER)
                    "MSVC Runtime",
    #elif defined (__CYGWIN__)
                    "Cygwin Runtime",
    #elif defined (_GCC_VER) && defined (_WIN64)
                    __mingw_get_crt_info(),
    #else
                    "MinGW Runtime " TX_QUOTE (__MINGW32_MAJOR_VERSION) "." TX_QUOTE (__MINGW32_MINOR_VERSION),
    #endif
                    (sizeof (void*) == sizeof (DWORD))? 32 : 64,

                    timeS + 4, timeS + 20, timeS + 11,              // These offsets are ANSI standardized
                    txGetModuleFileName(),
                    _getcwd (cwd, sizeof (cwd) - 1));

    return text;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib API implementation
//           Ðåàëèçàöèÿ TXLib API
//=================================================================================================================

inline const char* txVersion()
    {
    return _TX_VERSION;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txVersionNumber()
    {
    return _TX_VER;
    }

//-----------------------------------------------------------------------------------------------------------------

inline HWND txWindow()
    {
$0  return _txCanvas_Window;
    }

//-----------------------------------------------------------------------------------------------------------------

inline HDC& txDC()
    {
$0  return _txCanvas_BackBuf[0];
    }

//-----------------------------------------------------------------------------------------------------------------

inline RGBQUAD* txVideoMemory()
    {
    return _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetExtent (HDC dc /*= txDC()*/)
    {
$0  static POINT err = {-1, -1};

    if (!dc) {$ POINT screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) }; return screen; };

    if (_TX_DEFAULT_HDC_FAILED (dc)) {$ return err; }

$   BITMAP bmap = {};
$   txGDI (Win32::GetObject (Win32::GetCurrentObject (dc, OBJ_BITMAP), sizeof (bmap), &bmap), dc) asserted;

$   POINT  size = { bmap.bmWidth, bmap.bmHeight };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetExtentX (HDC dc /*= txDC()*/)
    {
    return txGetExtent (dc) .x;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetExtentY (HDC dc /*= txDC()*/)
    {
    return txGetExtent (dc) .y;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDestroyWindow (HWND wnd /*= txWindow()*/)
    {
$1  if (!wnd || !txWindow()) return false;

$   if (wnd != txWindow())
        {
$       return !!SendNotifyMessage (txWindow(), _TX_WM_DESTROYWND, 0, (LPARAM) wnd);
        }

$   if (SendNotifyMessage (txWindow(), (_txMain? WM_CLOSE : WM_DESTROY), 0, 0) == 0) return false;

$   if (_txMain)
        {
$       txNotifyIcon (NIIF_WARNING, NULL, "\n" "Î÷åíü, î÷åíü ïëîõî çàâåðøàòü ïðîãðàììó ÷åðåç txDestroyWindow().\n\n"
                                               "Âîçâðàùàéòåñü ÷åðåç main(), òàì âàì áóäóò ðàäû.\n");
$       Sleep (_TX_TIMEOUT);
        }

$   _txWaitFor (!_txCanvas_Window, _TX_TIMEOUT);

$   return _txCanvas_Window == NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

HPEN txSetColor (COLORREF color, double thickness /*= 1*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return NULL;

$   HPEN pen = Win32::CreatePen ((color == TX_TRANSPARENT? PS_NULL : PS_SOLID), ROUND (thickness), color);

$   if (!pen) return (HPEN) NULL;

$   if (!_txBuffer_Select (pen, dc))
        {
$       Win32::DeleteObject (pen);
$       return (HPEN) NULL;
        }

$   if (txGDI (Win32::SetTextColor (dc, color), dc) == CLR_INVALID)
        {$ return (HPEN) NULL; }

$   return pen;
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txColor (double red, double green, double blue)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;

$   COLORREF color = RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255));

$   return txSetColor (color)? color : CLR_INVALID;
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txGetColor (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;

$   HGDIOBJ obj = txGDI ((Win32::GetCurrentObject (dc, OBJ_PEN)), dc);
$   assert (obj); if (!obj) return CLR_INVALID;

$   union { EXTLOGPEN extLogPen; LOGPEN LogPen; } buf = {};

$   int size = Win32::GetObject (obj, 0, NULL);
$   Win32::GetObject (obj, sizeof (buf), &buf) asserted;

$   return (size == sizeof (LOGPEN))? buf.LogPen.lopnColor : buf.extLogPen.elpColor;
    }

//-----------------------------------------------------------------------------------------------------------------

HBRUSH txSetFillColor (COLORREF color, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return NULL;

$   HBRUSH brush = (color == TX_TRANSPARENT)? (HBRUSH) Win32::GetStockObject (HOLLOW_BRUSH) : Win32::CreateSolidBrush (color);

$   return (_txBuffer_Select (brush, dc))? brush : (Win32::DeleteObject (brush), (HBRUSH) NULL);
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txFillColor (double red, double green, double blue)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;

$   COLORREF color = RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255));

$   return txSetFillColor (color)? color : CLR_INVALID;
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txGetFillColor (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;

$   HGDIOBJ obj = txGDI ((Win32::GetCurrentObject (dc, OBJ_BRUSH)), dc);
$   assert (obj); if (!obj) return CLR_INVALID;

$   LOGBRUSH buf = {};
$   txGDI ((Win32::GetObject (obj, sizeof (buf), &buf)), dc) asserted;

$   return buf.lbColor;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClear (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT size = txGetExtent (dc);
$   return txGDI (!!(Win32::PatBlt (dc, 0, 0, size.x, size.y, PATCOPY)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txSetPixel (double x, double y, COLORREF color, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   txGDI ((Win32::SetPixel (dc, ROUND (x), ROUND (y), color)), dc);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txPixel (double x, double y, double red, double green, double blue, HDC dc /*= txDC()*/)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;

$   return txSetPixel (x, y, RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

inline COLORREF txGetPixel (double x, double y, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;

$   return txGDI ((Win32::GetPixel (dc, ROUND (x), ROUND (y))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLine (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   bool ok  = txGDI ((Win32::MoveToEx (dc, ROUND (x0), ROUND (y0), NULL)), dc);
$        ok &= txGDI ((Win32::LineTo   (dc, ROUND (x1), ROUND (y1)      )), dc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txRectangle (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   return txGDI ((Win32::Rectangle (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPolygon (const POINT points[], int numPoints, HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (points)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))     return false;

$   return txGDI (!!(Win32::Polygon (dc, points, numPoints)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txEllipse (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   return txGDI ((Win32::Ellipse (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txCircle (double x, double y, double r)
    {
$1  return txEllipse (x-r, y-r, x+r, y+r);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txArc (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };

$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;

$   return txGDI (!!(Win32::Arc (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                     ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                     ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPie (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };

$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;

$   return txGDI (!!(Win32::Pie (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                     ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                     ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txChord (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };

$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;

$   return txGDI (!!(Win32::Chord (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                       ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                       ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txFloodFill (double x, double y,
                  COLORREF color /*= TX_TRANSPARENT*/, DWORD mode /*= FLOODFILLSURFACE*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   if (color == TX_TRANSPARENT) color = txGetPixel (x, y, dc);

$   return txGDI (!!(Win32::ExtFloodFill (dc, ROUND (x), ROUND (y), color, mode)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextOut (double x, double y, const char text[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (text)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return false;

$   int len = (int) strlen (text);
$   bool ok = txGDI (!!(Win32::TextOut (dc, ROUND (x), ROUND (y), text, len)), dc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDrawText (double x0, double y0, double x1, double y1, const char text[],
                 unsigned format /*= DT_CENTER | DT_VCENTER | DT_WORDBREAK | DT_WORD_ELLIPSIS*/,
                 HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (text)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return false;

#if !defined (NDEBUG)

$   if (x0 > x1)
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïàðàìåòð x0 = %lg áîëüøå, ÷åì x1 = %lg. Òåêñò âûâîäèòüñÿ íå áóäåò.", x0, x1);
        }

$   if (y0 > y1)
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïàðàìåòð y0 = %lg áîëüøå, ÷åì y1 = %lg. Òåêñò âûâîäèòüñÿ íå áóäåò.", y0, y1);
        }

#endif

$   RECT r = { ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1) };

$   if (!strchr (text, '\n')) format |= DT_SINGLELINE;

$   unsigned prev = txSetTextAlign (TA_LEFT | TA_TOP | TA_NOUPDATECP, dc);

$   bool ok = false;

$   if (Win32::DrawText)
        {
$       ok = !!txGDI ((Win32::DrawText (dc, text, -1, &r, format)), dc);
$       Win32::GetPixel (dc, 0, 0);
$       ok = true;
        }
    else
        {
$       txTextOut ((x0 + x1) / 2, (y0 + y1) / 2, text);
$       ok = false;
        }

$   txSetTextAlign (prev, dc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

HFONT txSelectFont (const char name[], double sizeY, double sizeX /*= -1*/,
                    int bold /*= FW_DONTCARE*/, bool italic /*= false*/, bool underline /*= false*/,
                    bool strikeout /*= false*/, double angle /*= 0*/,
                    HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (name)) return NULL;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return NULL;

$   HFONT font = txFontExist (name)?
                     Win32::CreateFont (ROUND (sizeY), ROUND ((sizeX >= 0)? sizeX : sizeY/3),
                                        ROUND (angle*10), 0, bold, italic, underline, strikeout,
                                        RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                        DEFAULT_QUALITY, DEFAULT_PITCH, name)
                     :
                     (HFONT) Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, dc);

$   return font;
    }

//-----------------------------------------------------------------------------------------------------------------

SIZE txGetTextExtent (const char text[], HDC dc /*= txDC()*/)
    {
$1  SIZE size = {-1, -1};

$   if (_TX_ARGUMENT_FAILED    (text)) return size;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return size;

$   size_t len = strlen (text);
$   txGDI ((Win32::GetTextExtentPoint32 (dc, text, (int) len, &size)), dc) asserted;

$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetTextExtentX (const char text[], HDC dc /*= txDC()*/)
    {
$1  return txGetTextExtent (text, dc) .cx;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetTextExtentY (const char text[], HDC dc /*= txDC()*/)
    {
$1  return txGetTextExtent (text, dc) .cy;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetTextAlign (unsigned align /*= TA_CENTER | TA_BASELINE*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   return txGDI ((Win32::SetTextAlign (dc, align)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

LOGFONT* txFontExist (const char name[])
    {
$1  if (_TX_ARGUMENT_FAILED (name)) return NULL;

$   static LOGFONT font = {};
$   font.lfCharSet = DEFAULT_CHARSET;
$   strncpy_s (font.lfFaceName, sizeof (font.lfFaceName), name, sizeof (font.lfFaceName) - 1);

$   struct tools
        {
        static int CALLBACK enumFonts (const LOGFONT* fnt, const TEXTMETRIC*, DWORD, LPARAM data)
            {
$           if (_TX_ARGUMENT_FAILED (fnt))  return 0;
$           if (_TX_ARGUMENT_FAILED (data)) return 0;

            #ifndef __STRICT_ANSI__
$           return _strnicmp (fnt->lfFaceName, ((LOGFONT*)data)->lfFaceName, LF_FACESIZE);

            #else
$           return  strncmp  (fnt->lfFaceName, ((LOGFONT*)data)->lfFaceName, LF_FACESIZE);

            #endif
            }
        };

$   return txGDI ((Win32::EnumFontFamiliesEx (NULL, &font, tools::enumFonts, (LPARAM) &font, 0)), NULL) == 0? &font : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSelectObject (HGDIOBJ obj, HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (obj)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))  return false;

$   return _txBuffer_Select (obj, dc);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txCreateCompatibleDC (double sizeX, double sizeY, HBITMAP bitmap /*= NULL*/)
    {
$1  POINT size = { ROUND (sizeX), ROUND (sizeY) };

$   HDC dc = _txBuffer_Create (NULL, &size, bitmap);
$   assert (dc); if (!dc) return NULL;

$   txSetDefaults (dc);

$   if (!_txCanvas_UserDCs) return dc;

$   txAutoLock _lock;
$   _txCanvas_UserDCs->push_back (dc);

$   if (_txCanvas_UserDCs->size() >= _TX_BUFSIZE)
        {$ txNotifyIcon (NIIF_WARNING, NULL, "Âû çàãðóçèëè óæå %d HDC, ñèñòåìå ìîæåò ñòàòü ïëîõî.", (int) _txCanvas_UserDCs->size()); }

$   return dc;
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txCreateDIBSection (double sizeX, double sizeY, RGBQUAD** pixels /*= NULL*/)
    {
$1  RGBQUAD* buf = NULL;
$   if (!pixels) pixels = &buf;

$   BITMAPINFO info = {{ sizeof (info), ROUND (sizeX), ROUND (sizeY), 1, WORD (sizeof (RGBQUAD) * 8), BI_RGB }};

$   HDC dc = txCreateCompatibleDC (0, 0, Win32::CreateDIBSection (NULL, &info, DIB_RGB_COLORS, (void**) pixels, NULL, 0));

$   RGBQUAD black = { 0, 0, 0, 255 };
$   for (int i = 0; i < sizeX * sizeY; i++) (*pixels)[i] = black;

$   return dc;
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txCreateDIBSection (double sizeX, double sizeY, COLORREF** pixels)
    {
$1  return txCreateDIBSection (sizeX, sizeY, (RGBQUAD**) pixels);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txLoadImage (const char filename[], unsigned imageFlags /*= IMAGE_BITMAP*/, unsigned loadFlags /*= LR_LOADFROMFILE*/)
    {
$1  if (_TX_ARGUMENT_FAILED (filename && *filename)) return NULL;

$   HBITMAP image = (HBITMAP) Win32::LoadImage ((loadFlags & LR_LOADFROMFILE)? NULL : GetModuleHandle (NULL),
                                                 filename, imageFlags, 0, 0, loadFlags);
$   if (!image) return NULL;

$   HDC dc = txCreateCompatibleDC (0, 0, image);

$   if (!(loadFlags & LR_LOADFROMFILE)) return dc;

$   static std::map <std::string, unsigned> loadTimes;
$   std::string file = filename;
$   unsigned time    = GetTickCount();

$   if ((long) (time - loadTimes [file]) < _TX_TIMEOUT)
        {$ txNotifyIcon (NIIF_WARNING, NULL, "Âû çàãðóæàåòå \"%s\" ñëèøêîì ÷àñòî, ïðîãðàììà áóäåò òîðìîçèòü.", filename); }

$   loadTimes [file] = time;

$   return dc;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDeleteDC (HDC* pdc)
    {
$1  if (_TX_ARGUMENT_FAILED (pdc)) return false;

$   HDC  dc = *pdc;
$   bool ok = _txBuffer_Delete (pdc);
$   if (!ok) return false;

$   if (!_txCanvas_UserDCs) return ok;

$   txAutoLock _lock;
$   std::vector <HDC> ::iterator it = std::find (_txCanvas_UserDCs->begin(), _txCanvas_UserDCs->end(), dc);
$   if  (it != _txCanvas_UserDCs->end()) { std::swap (*it, _txCanvas_UserDCs->back()); _txCanvas_UserDCs->pop_back(); }

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDeleteDC (HDC dc)
    {
$1  return txDeleteDC (&dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txBitBlt (HDC destImage,   double xDest, double yDest, double width, double height,
               HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, unsigned operation /*= SRCCOPY*/)
    {
$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;

$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;

$   return txGDI (!!(Win32::BitBlt (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                    sourceImage, ROUND (xSource), ROUND (ySource), operation)), destImage);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txBitBlt (double xDest, double yDest, HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txBitBlt (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTransparentBlt (HDC destImage,   double xDest, double yDest, double width, double height,
                       HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, COLORREF transColor /*= TX_BLACK*/)
    {
$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;

$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;

#if !defined (NDEBUG)

$   if (!(0 <= xSource && xSource + width  <= size.x &&
          0 <= ySource && ySource + height <= size.y))
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïðÿìîóãîëüíèê êîïèðóåìîé îáëàñòè {%lg, %lg, %lg, %lg} íå ïîëíîñòüþ ëåæèò âíóòðè èçîáðàæåíèÿ-èñòî÷íèêà {%d, %d, %d, %d}, "
                  "ôóíêöèÿ txTransparentBlt() ðàáîòàòü íå áóäåò.", xSource, ySource, xSource + width, ySource + height, 0, 0, (int) size.x, (int) size.y);
        }

#endif

$   bool ok = (Win32::TransparentBlt != NULL);

$   if (ok)
        {
$       ok &= txGDI (!!(Win32::TransparentBlt (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                               sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), transColor)),
                                               destImage);
        }
    else
        {
$       ok &= txGDI (!!(Win32::BitBlt         (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                               sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                               destImage);
        }

    return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txTransparentBlt (double xDest, double yDest, HDC sourceImage,
                              COLORREF transColor /*= TX_BLACK*/, double xSource /*= 0*/, double ySource /*= 0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txTransparentBlt (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, transColor);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txAlphaBlend (HDC destImage,   double xDest, double yDest, double width, double height,
                   HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
    // Ýòî ïðîâåðêè òîãî, ïðàâèëüíûå ëè HDC âû ïåðåäàëè â ôóíêöèþ.
    // Íå áîéòåñü äîëëàðîâ - <s>ýòî íå çàïðåùåííàÿ âàëþòà</s> ýòî ìàêðîñû äëÿ îòëàäêè TXLib'à.

$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;

    // Ýòî àâòîìàòè÷åñêîå îïðåäåëåíèå ðàçìåðîâ êàðòèíêè (òî÷íåå, HDC èñòî÷íèêà - source) ñ ïîìîùüþ txGetExtent().

$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;

    // Ýòî ïðîâåðêà òîãî, ÷òî êàðòèíêà (èëè åå ÷àñòü) ïðàâèëüíî ïîïàäàåò â îêíî (òî÷íåå, HDC ïðèåìíèêà - destination, dest).
    // Åñëè îíà "âûëåçàåò" èç îêíà â ëþáóþ ñòîðîíó, òî Win32::AlphaBlend íå áóäåò ðàáîòàòü. Ýòà ïðîâåðêà ïðîèñõîäèò òîëüêî
    // â ðåæèìå îòëàäêè (êîãäà íå çàäàí ìàêðîñ NDEBUG - No Debugging, áåç îòëàäêè).

#if !defined (NDEBUG)

$   if (!(0 <= xSource && xSource + width  <= size.x &&
          0 <= ySource && ySource + height <= size.y))
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïðÿìîóãîëüíèê êîïèðóåìîé îáëàñòè {%lg, %lg, %lg, %lg} íå ïîëíîñòüþ ëåæèò âíóòðè èçîáðàæåíèÿ-èñòî÷íèêà {%d, %d, %d, %d}, "
                  "ôóíêöèÿ txAlphaBlend() ðàáîòàòü íå áóäåò.", xSource, ySource, xSource + width, ySource + height, 0, 0, (int) size.x, (int) size.y);
        }

#endif

    // Ýòî íà ñëó÷àé, åñëè ïàðàìåòð alpha âûëåçàåò çà äèàïàçîí [0..1].

$   if (alpha < 0) alpha = 0;
$   if (alpha > 1) alpha = 1;

    // Îá ýòîì ñì. íèæå.

$   BITMAP bmap = { 0, 0, 0, 0, 0, 24 };
$   bool ok = !!Win32::GetObject (txGDI ((Win32::GetCurrentObject (sourceImage, OBJ_BITMAP)), sourceImage), sizeof (bmap), &bmap);

    //
    // * Ñòðóêòóðà BLENDFUNCTION *
    //
    // Ýòà ñòðóêòóðà îïðåäåëÿåò, êàê öâåòà ïèêñåëåé îêíà (òî÷íåå, source DC) è êàðòèíêè ñìåøèâàþòñÿ ïðè ðèñîâàíèè ñ ó÷åòîì
    // ïðîçðà÷íîñòè.
    //
    // Ïàðàìåòðû ñìåøèâàíèÿ ïîìåùàþòñÿ â ãðóïïó èç ïåðåìåííûõ - òàê íàçûâàåìóþ ñòðóêòóðó. Ïåðåìåííûå, âõîäÿùèå â ñòðóêòóðó,
    // íàçûâàþòñÿ êîìïîíåíòàìè ñòðóêòóðû.
    //
    //  ýòîé ñòðóêòóðå áîëåå âñåõ âàæåí åå òðåòèé êîìïîíåíò (ñì. íèæå), çàäàþùèé ïðîçðà÷íîñòü êàðòèíêè.
    // Åñëè îí ðàâåí íóëþ - òî êàðòèíêà áóäåò ñ÷èòàòüñÿ ïîëíîñòüþ ïðîçðà÷íîé è âûçîâ Win32::AlphaBlend íè÷åãî íå íàðèñóåò.
    // Åñëè îí ðàâåí 255  - òî êàðòèíêà ñêîïèðóåòñÿ â îêíî ïîëíîñòüþ, áåç ýôôåêòà ïðîçðà÷íîñòè.
    //
    // Ñ ïîìîùüþ ÷åòâåðòîãî êîìïîíåíòà ñòðóêòóðû ñèñòåìà ðèñîâàíèÿ Windows (Win32 GDI) óçíàåò, íàäî ëè ó÷èòûâàòü àëüôà-êàíàë
    // â êîïèðóåìîé êàðòèíêå èëè åãî íàäî èãíîðèðîâàòü. Åñëè â êàðòèíêå ôàêòè÷åñêè åñòü ïðàâèëüíî ïîñòðîåííûé àëüôà-êàíàë
    // (ñì. îïèñàíèå ôóíêöèè txAlphaBlend â ñèñòåìå ïîìîùè TXLib), òî ÷åòâåðòûé êîìïîíåíò ñòðóêòóðû íàäî çàäàòü êàê êîíñòàíòó
    // AC_SRC_ALPHA.
    //
    // Åñëè â êàðòèíêå àëüôà-êàíàëà ôàêòè÷åñêè íåò, òî ÷åòâåðòûé ïàðàìåòð íàäî óñòàíîâèòü â 0.
    //
    //  êîäå íèæå ÷åòâåðòûé ïàðàìåòð îïðåäåëÿåòñÿ àâòîìàòè÷åñêè èç âûçîâà Win32::GetObject(), äëÿ óíèâåðñàëüíîñòè ïðèìåíåíèÿ
    // ôóíêöèè txAlphaBlend().
    //
    // Ïîæàëóéñòà, íå íàäî áåçäóìíî êîïèðîâàòü ñåáå â ïðîãðàììó ýòîò êîä. Îñìûñëèòå åãî, è ðåøèòå, áóäåòå ëè âû èñïîëüçîâàòü
    // àëüôà-êàíàë èëè íåò, è óñòàíîâèòå ÷åòâåðòûé ïàðàìåòð ñòðóêòóðû ëèáî AC_SRC_ALPHA, ëèáî 0. Èíà÷å ýòèì êîïèïàñòîì âû
    // ïîðîäèòå íåâíÿòíûé ïàëåíûé êîä è áåçíàäåæíî èñïîðòèòå ñåáå êàðìó. :((
    //
    // Íà äîëëàðû ($) íå îáðàùàéòå âíèìàíèÿ, îíè íóæíû äëÿ îòëàäêè áèáëèîòåêè TXLib. Â âàøåé ïðîãðàììå èõ èñïîëüçîâàòü íå íàäî.
    //
    //                       ____1____   2   ___________3___________     _______________________4________________________
    //                      /         \  |  /                       \   /                                                \.

$   BLENDFUNCTION blend = { AC_SRC_OVER, 0, (BYTE) ROUND (alpha * 255), (BYTE) ((bmap.bmBitsPixel == 32)? AC_SRC_ALPHA : 0) };

    //
    // * Âûçîâ ñòàíäàðòíîé ôóíêöèè Win32::AlphaBlend() *
    //
    // Íèæå - ýòî âûçîâ Win32::AlphaBlend(). Îí òàê óñòðîåí, ÷òî, åñëè âäðóã ÷òî-òî íå ïîëó÷èëîñü (ò.å. Win32::AlphaBlend()
    // âåðíåò 0), òî òîãäà áóäåò âûçâàíà Win32::BitBlt(), êîòîðàÿ ïðîñòî ñêîïèðóåò êàðòèíêó áåç ó÷åòà ïðîçðà÷íîñòè. Ïîãóãëèòå
    // "Windows AlphaBlend function" è ïî÷èòàéòå ïðî åå ïàðàìåòðû.
    //
    // Êàê âèäèòå, îðèãèíàëüíàÿ ôóíêöèÿ èç Win32 ïðèíèìàåò ðàçìåðû íå òîëüêî èñõîäíîé, íî è èòîãîâîé êàðòèíêè, è åñëè îíè íå
    // ñîâïàäàþò, òî êàðòèíêà áóäåò óìåíüøåíà èëè óâåëè÷åíà. TXlib'îâñêàÿ <s>ïàëåíàÿ</s> ôóíêöèÿ txAlphaBlend ïðåäïîëàãàåò, ÷òî
    // ýòè ðàçìåðû âñåãäà ñîâïàäàþò, è ïîýòîìó ïðè ðàáîòå ñ txAlphaBlend() ìàñøòàá áóäåò âñåãäà 1:1. <s>Òàê ñåáå ðåøåíèå, íî</s>
    // ýòî ñäåëàíî äëÿ óïðîùåíèÿ âûçîâà ôóíêöèè txAlphaBlend().

$   if (Win32::AlphaBlend) // Òîëüêî òî, ÷òî ýòè ïàðàìåòðû ïåðåäàþòñÿ îäèíàêîâûìè, íå äàåò âîçìîæíîñòü ìåíÿòü ìàñøòàá êàðòèíêè!   // <<--
        {                  //                           //                                       vvvvv          vvvvvv            // <<--
$       ok &= txGDI (!!(Win32::AlphaBlend (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),          // <<==
                                           sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), blend)), // <<==
                                           destImage);  //                                       ^^^^^          ^^^^^^            // <<--
        }                  //                                                                    |||||          ||||||            // <<--
                           // Ñì. "AlphaBlend function" â Google, èùèòå ñìûñë ïàðàìåòðîâ wSrc è wDest (hSrc è hDest). Äóìàéòå!    // <<--

    else
        {
$       ok &= txGDI (!!(Win32::BitBlt     (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                           sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                           destImage);
$       ok = false;
        }

    //  ýòîé ôóíêöèè ïðîâåðîê è êîììåíòàðèåâ áîëüøå, ÷åì ðàáî÷åãî êîäà, è ýòî êàê áû íàìåêàåò, ÷òî íåòðóäíî ñäåëàòü ñâîþ
    // àíàëîãè÷íóþ ôóíêöèþ áåç îãðàíè÷åíèé ìàñøòàáà îòîáðàæåíèÿ. <s>Åñëè òû äî÷èòàë äî ýòîãî ìåñòà,</s> ïåðåñÿäü ñ èãëû TXLib'à
    // íà ïîâåðõíîñòü GDI Win32, <s>õîòÿ GDI òîæå òàê ñåáå, òàê ÷òî ëó÷øå çàþçàé GDI+, SFML, OpenGL èëè DirectX, áóäåò êðóòî.
    // Õîòÿ ýòî è ñëîæíåå.</s>

    // Íî ïîìíè ïðî ïàëåíûé êîïèïàñò è êàðìó, ñì. âûøå. ß ïðåäóïðåäèë.

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txAlphaBlend (double xDest, double yDest, HDC sourceImage,
                          double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txAlphaBlend (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, alpha);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txUseAlpha (HDC image)
    {
$1  if (_TX_HDC_FAILED (image)) return NULL;

$   HBITMAP bitmap = (HBITMAP) Win32::GetCurrentObject (image, OBJ_BITMAP);
$   if (!bitmap) return NULL;

$   DIBSECTION dib = {};
$   Win32::GetObject (bitmap, sizeof (dib), &dib) asserted;

$   POINT      size = {  dib.dsBm.bmWidth, dib.dsBm.bmHeight };
$   BITMAPINFO info = {{ sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB }};
$   RGBQUAD*   buf  = NULL;

$   bool isDIB = (dib.dsBm.bmPlanes        == 1                    &&
                  dib.dsBm.bmBitsPixel     == sizeof (RGBQUAD) * 8 &&
                  dib.dsBmih.biCompression == DIB_RGB_COLORS       &&
                  dib.dsBm.bmBits);
$   if (!isDIB)
        {
$       buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$       if (!buf) return NULL;

$       Win32::GetDIBits (image, bitmap, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;
        }
    else
        {
$       buf = (RGBQUAD*) dib.dsBm.bmBits;
        }

$   for (int y = 0; y < size.y; y++)
    for (int x = 0; x < size.x; x++)
        {
        RGBQUAD* color = &buf [x + y * size.x];  // Get color at (x, y) within image buffer

        color->rgbRed   = (BYTE) ROUND (color->rgbRed   * color->rgbReserved / 255.0);
        color->rgbGreen = (BYTE) ROUND (color->rgbGreen * color->rgbReserved / 255.0);
        color->rgbBlue  = (BYTE) ROUND (color->rgbBlue  * color->rgbReserved / 255.0);
        }

$   if (!isDIB)
        {
$       Win32::SetDIBitsToDevice (image, 0, 0, size.x, size.y, 0, 0, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;

$       delete[] buf;
        }

$   return image;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSaveImage (const char filename[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (filename)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))       return false;

$   POINT size = txGetExtent (dc);

$   size_t szHdrs = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER),
           szImg  = (size.x * size.y) * sizeof (RGBQUAD);

$   BITMAPFILEHEADER hdr  = { 0x4D42 /* 'MB' */, (DWORD) (szHdrs + szImg), 0, 0, (DWORD) szHdrs };
$   BITMAPINFOHEADER info = { sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB };

$   bool ok = true;

$   RGBQUAD* buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$   ok &= (buf != NULL);

$   if (ok) Win32::GetDIBits (dc, (HBITMAP) Win32::GetCurrentObject (dc, OBJ_BITMAP), 0, size.y,
                              buf, (BITMAPINFO*) &info, DIB_RGB_COLORS) asserted;
$   FILE* f = NULL;
$   if (ok) fopen_s (&f, filename, "wb");
$   ok &= (f != NULL);

$   if (ok) ok &= (fwrite (&hdr,  sizeof (hdr),  1, f) == 1);
$   if (ok) ok &= (fwrite (&info, sizeof (info), 1, f) == 1);
$   if (ok) ok &= (fwrite (buf,   szImg,         1, f) == 1);

$   ok &= (f && fclose (f) == 0);

$   delete[] buf;
$   buf = NULL;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline void txRedrawWindow()
    {
$1  txSleep (0);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txUpdateWindow (int update /*= true*/)
    {
$1  return _txCanvas_SetRefreshLock (update >= 0? !update : -update);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txBegin()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock + 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txEnd()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock - 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

double txSleep (double time)
    {
$1  LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   int lock = _txCanvas_RefreshLock;
$   _txCanvas_RefreshLock = 0;

$   HWND wnd = txWindow();
    if (wnd) {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   Sleep (ROUND ((time >= 0)? time : 0));

$   _txCanvas_RefreshLock = lock;

$   LARGE_INTEGER stop = {};
$   QueryPerformanceCounter (&stop) asserted;

$   return 1000.0 * (double) (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLock (bool wait /*= true*/)
    {
$0  if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);

$   if (wait) {$ return      EnterCriticalSection (&_txCanvas_LockBackBuf), true; }
    else      {$ return !!TryEnterCriticalSection (&_txCanvas_LockBackBuf);       }
    }

//-----------------------------------------------------------------------------------------------------------------

bool txUnlock()
    {
$0  LeaveCriticalSection (&_txCanvas_LockBackBuf);

$   if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T txUnlock (T value)
    {
$1  txUnlock();
$   return value;
    }

//-----------------------------------------------------------------------------------------------------------------

inline POINT txMousePos()
    {
$1  POINT pos = {};
$   GetCursorPos (&pos);

$   if (txWindow())
        {$ ScreenToClient (txWindow(), &pos); }

$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseX()
    {
    return txMousePos() .x;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseY()
    {
    return txMousePos() .y;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txMouseButtons()
    {
$1  return ((GetAsyncKeyState (VK_LBUTTON) & 0x8000) >> 15) |  // MSB to bit 0
           ((GetAsyncKeyState (VK_RBUTTON) & 0x8000) >> 14) |  // MSB to bit 1
           ((GetAsyncKeyState (VK_MBUTTON) & 0x8000) >> 13);   // MSB to bit 2
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetConsoleAttr (unsigned color /*= FOREGROUND_LIGHTGRAY*/)
    {
    unsigned oldAttr = txGetConsoleAttr();

    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), (WORD) color);

    return oldAttr;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txGetConsoleAttr()
    {
    CONSOLE_SCREEN_BUFFER_INFO con = {};
    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);

    return con.wAttributes;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txSetConsoleCursorPos (double x, double y)
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   COORD pos = { (short) ROUND (1.0 * x / fontSz.x + con.srWindow.Left),
                  (short) ROUND (1.0 * y / fontSz.y + con.srWindow.Top ) };

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos) asserted;

$   POINT prev = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return prev;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleCursorPos()
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  pos = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleExtent()
    {
$1  CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  size = { con.srWindow.Right  - con.srWindow.Left + 1,
                    con.srWindow.Bottom - con.srWindow.Top  + 1 };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClearConsole()
    {
$1  HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (out, &con) asserted;

$   COORD start = {con.srWindow.Left, con.srWindow.Top};

$   DWORD len   = (con.srWindow.Right  - con.srWindow.Left + 1) *
                  (con.srWindow.Bottom - con.srWindow.Top  + 1);

$   DWORD written = 0;
$   FillConsoleOutputCharacter (out, 0x20 /*' '*/,    len, start, &written) asserted;
$   FillConsoleOutputAttribute (out, con.wAttributes, len, start, &written) asserted;

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), start) asserted;

$   return written == len;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleFontSize()
    {
$1  Win32::CONSOLE_FONT_INFO font = {0, {8, 16}};

$   _TX_CALL (Win32::GetCurrentConsoleFont, (GetStdHandle (STD_OUTPUT_HANDLE), false, &font));

$   SIZE size = { font.dwFontSize.X, font.dwFontSize.Y };
$   txGDI (Win32::GetTextExtentPoint32 (_txCanvas_BackBuf[1], "W", 1, &size), txDC());

$   POINT sizeFont = { size.cx, size.cy };
$   return sizeFont;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextCursor (bool blink /*= true*/)
    {
$1  bool old = _txConsole_IsBlinking;

$   _txConsole_IsBlinking = blink;

$   return old;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPlaySound (const char filename[] /*= NULL*/, DWORD mode /*= SND_ASYNC*/)
    {
$1  mode |= SND_FILENAME | SND_NODEFAULT | SND_NOWAIT;
$   if (mode & SND_LOOP) mode = (mode & ~SND_SYNC) | SND_ASYNC;

$   if (!filename) mode = SND_PURGE;

$   return !!Win32::PlaySound (filename, NULL, mode);
    }

//-----------------------------------------------------------------------------------------------------------------

int txSpeak (const char* text, ...)
    {
$1  bool verbose = false; (void) verbose;
$   bool async   = false; (void) async;

$   for (; text && *text; text++)
        {
        if      (*text == '\a') {$ async   = true; }
        else if (*text == '\v') {$ verbose = true; }
        else break;
        }

$   char textA [_TX_BUFSIZE] = "You asked to speak empty text. I would rather say that TX Library is cool! Cats rules!";

$   va_list arg; va_start (arg, text);
    if (text && *text) {$ _tx_vsnprintf_s (textA, sizeof (textA) - 1, text, arg); }
$   va_end (arg);

#ifdef TX_USE_SPEAK

    if (text && verbose) {$ printf ("%s", textA); }

$   int time = GetTickCount();

$   static wchar_t textW [_TX_BUFSIZE * sizeof (wchar_t)] = L"";
$   MultiByteToWideChar (_TX_CODEPAGE, 0, textA, -1, textW, sizearr (textW));

$   static ISpVoice* voice = NULL;

$   if (text && !voice)
        {
$       HRESULT res = Win32::CoInitialize (NULL);
        if (res == S_OK) {$ Win32::CoCreateInstance (Win32::CLSID_SpVoice, NULL, CLSCTX_ALL, Win32::IID_ISpVoice, (void**) &voice); }
        }

$   if (text && voice)
        {
$       Win32::_fpreset();
$       voice->Speak (textW, SPF_PERSIST_XML | SPF_PURGEBEFORESPEAK | (async? SPF_ASYNC : 0), NULL);
$       tx_fpreset();
        }

$   if (!text && voice)
        {
$       voice->Release();
$       voice = NULL;

$       Win32::CoUninitialize();
        }

$   return (voice)? GetTickCount() - time : -1;

#else

$   if (text)
        {
$       unsigned oldAttr = txSetConsoleAttr (FOREGROUND_LIGHTRED | BACKGROUND_BLACK);

$       txNotifyIcon (NIIF_ERROR, "txSpeak(): Íå ìîãó ïðîèçíåñòè (íóæåí TX_USE_SPEAK, ñì. TXLib Help)", "\n" "%s", textA);

$       txSetConsoleAttr (oldAttr);
        }

$   return -1;

#endif
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txPlayVideo (int x, int y, int width, int height, const char fileName[],
                      double zoom /*= 0*/, double gain /*= 1*/, HWND wnd /*= txWindow()*/)
    {
$1  if (wnd && wnd == txWindow() && _TX_TXWINDOW_FAILED()) return -1;

$   int time = GetTickCount();

$   static char processUID [64] = "";
    if (!*processUID)
        {
$       FILETIME startTime = {}, null = {};
$       GetProcessTimes (GetCurrentProcess(), &startTime, &null, &null, &null) asserted;
$       _snprintf_s (processUID, sizeof (processUID) - 1, "TXLib[%08X%08X]::txPlayVideo",
                    (unsigned) startTime.dwHighDateTime, (unsigned) startTime.dwLowDateTime) < (int) sizeof (processUID) asserted;
        }

$   if (!fileName)
        {
$       txTaskKill ("vlc.exe", processUID, 0);  // Kill'em all, by command line pattern
$       return 0;
        }

$   static const char* vlcPath = _txPlayVideo_FindVLC();

$   if (!vlcPath || _access (vlcPath, 0) != 0)
        {
$       static int once = false;

$       if (*fileName && !once++)
            {$ txOutputDebugPrintf ("\a" "Íå íàéäåí âèäåîïðîèãðûâàòåëü VideoLAN (vlc.exe). Cêà÷àéòå åãî ñ ñàéòà VideoLAN.org "
                                    "è óñòàíîâèòå. Áåç óñòàíîâêè VideoLAN âèäåî âîñïðîèçâîäèòüñÿ íå áóäåò :(\n\n"
                                    "--\n" "Âñåãäà Âàøà, ôóíêöèÿ " /* êàê áû */ "txPlayVideo()...\n"
                                    "P.S. Ñì. ìîå îïèñàíèå â TXLib Help."); }
$       return INT_MIN;
        }

$   bool async = false;
    if (*fileName == '\a') {$ async = true; fileName++; }

$   RECT rect = {};
    if (wnd) {$ GetClientRect (wnd, &rect); }

    if (!width)  {$ width  = rect.right;  }
    if (!height) {$ height = rect.bottom; }

    // Create a child window to hold the video stream

$   const char* errPos = "ÂÍÅÇÀÏÍÎ";

$   volatile HWND child = NULL;
$   if (wnd && (wnd == txWindow()))
        {
$       const char* wndClass = txRegisterClass ("txPlayVideo", _txPlayVideo_WndProc, 0, NULL_BRUSH, 1);

$       static int number = 1;
$       CREATESTRUCT createData = { NULL, NULL, (HMENU) (size_t) number++, txWindow(), height, width, y, x,
                                    WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, __func__, wndClass };
$       child = txCreateExtraWindow (createData);
$       if (!child)
            {
$           txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                       strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå ìîãó ñîçäàòü îêíî äëÿ âèäåî :("), errPos));
$           return INT_MIN+3;
            }

$       BringWindowToTop (child);

$       wnd = child;
        }

    // Build the command line

    if (!zoom && !wnd) {$ zoom = 1; }

$   char sZoom [64] = "--autoscale";
    if (zoom) {$ _snprintf_s (sZoom, sizeof (sZoom) - 1, "--no-autoscale --zoom=%.10g", zoom) < (int) sizeof (sZoom) asserted; }

$   static char cmd [MAX_PATH*2 + 1024] = "";

$   _snprintf_s (cmd, sizeof (cmd) - 1, "\"%s\" \"%s\" vlc://quit"

                 " %s --gain=%.10g --drawable-hwnd=%" PRIu64 " --video-title=\"%s\" --logfile=%s"

                 " --live-caching=500 --network-caching=500 --quiet-synchro --no-embedded-video --file-logging"

                 " --ignore-config --reset-config --no-one-instance --play-and-exit"
                 " --intf=dummy --dummy-quiet --quiet --no-video-deco --no-video-title-show --no-stats --no-sub-autodetect-file"
                 " --no-disable-screensaver --no-snapshot-preview --no-auto-preparse --no-mouse-events --no-keyboard-events",

                 vlcPath, (*fileName? fileName : "fileName"), sZoom, gain, (uint64_t) wnd, processUID, _txLogName) < (int) sizeof (cmd) asserted;

$   txOutputDebugPrintf ("txPlayVideo (%d, %d, %d, %d, \"%s\", %lg, %lg, %p): [%s]\n\n",
                         x, y, width, height, fileName, zoom, gain, wnd, cmd);
$   if (!*fileName)
        {
        if (child) {$ txDestroyWindow (child); }
$       return (intptr_t) cmd;
        }

$   if (!strstr (fileName, "://") && _access (fileName, 0) != 0)
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå íàéäåí ôàéë \"%s\"", fileName), errPos));

        if (child) {$ txDestroyWindow (child); }
$       return INT_MIN+1;
        }

    // Run VLC, run

$   PROCESS_INFORMATION vlc   = {};
$   STARTUPINFO         start = { sizeof (start) };
$   DWORD               ret   = 0;

$   if (CreateProcess (NULL, cmd, NULL, NULL, true, 0, NULL, NULL, &start, &vlc) &&
        vlc.hProcess && vlc.hThread)
        {
$       if (child)
            {
$           assert (wnd == child);
$           SetWindowLongPtr (wnd, GWLP_USERDATA, (LONG_PTR) vlc.hProcess);
            }

$       if (!async)
            {
$           WaitForSingleObject (vlc.hProcess, INFINITE);
$           GetExitCodeProcess  (vlc.hProcess, &ret) asserted;
            }

$       if (!child)
            {
$           CloseHandle (vlc.hProcess) asserted;
            }

$       CloseHandle (vlc.hThread) asserted;

$       return (async? (intptr_t) wnd : (ret == 0)? time - GetTickCount() : - (int) ret);
        }
    else
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Îøèáêà çàïóñêà VideoLAN (%s)", cmd), errPos));
$       if (child)
            {$ txDestroyWindow (child); }

$       return INT_MIN+4;
        }

    #undef PROCESS_UID_
    }

//-----------------------------------------------------------------------------------------------------------------

inline intptr_t txPlayVideo (const char fileName[], double zoom /*= 0*/, double gain /*= 0*/, HWND wnd /*= txWindow()*/)
    {
$1  return txPlayVideo (0, 0, 0, 0, fileName, zoom, gain, wnd);
    }

//-----------------------------------------------------------------------------------------------------------------

LRESULT CALLBACK _txPlayVideo_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
    const UINT_PTR checkTimer = 1;

    switch (msg)
        {
        case WM_CREATE:
            {
$1          SetTimer  (wnd, checkTimer, 5*_txWindowUpdateInterval, NULL) asserted;
            }
            break;

        case WM_DESTROY:
            {
$1          KillTimer (wnd, checkTimer) asserted;

$           HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

$           if (vlc)
                {
$               Win32::TerminateProcess (vlc, 0);

$               CloseHandle (vlc) asserted;

$               SetWindowLongPtr (wnd, GWLP_USERDATA, 0);
                }
            }
            break;

        case WM_TIMER:
            {
            HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

            if (vlc && WaitForSingleObject (vlc, 0) != WAIT_TIMEOUT)
                {
$1              DestroyWindow (wnd) asserted;
                }
            }
            break;

        default:
            break;
        }

    return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txPlayVideo_FindVLC()
    {
$1  static char vlcPath [MAX_PATH] = "";

$   if (SearchPath (NULL, "vlc.bat", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (SearchPath (NULL, "vlc.exe", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", NULL, vlcPath, sizeof (vlcPath)))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", "InstallDir", vlcPath, sizeof (vlcPath)))
        {
$       strncat_s (vlcPath, sizeof (vlcPath) - 1, "\\vlc.exe", INT_MAX);

        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files"    "\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   return NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// +--<<< Ýòî âðÿä ëè èìååò îòíîøåíèå ê òîìó, ÷òî âû èùåòå :)
// V      Ïîëåçíî ñìîòðåòü íå òîëüêî ââåðõ, íî è âíèç

WNDPROC txSetWindowsHook (WNDPROC wndProc /*= NULL*/)
    {
$1  WNDPROC old = _txAltWndProc; _txAltWndProc = wndProc;
$   return  old;
    }

//-----------------------------------------------------------------------------------------------------------------

//     +--<<< À ýòî, íàêîíåö, èñêîìîå îïðåäåëåíèå ýòîé ôóíêöèè.
//     |      Ñìîòðèòå ïî ñòîðîíàì! Íóæíàÿ âàì ôóíêöèÿ ãäå-òî ðÿäîì.
//     |
//     v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()
    {
    txMessageBox ("Ýòî çàïëàíèðîâàííàÿ îøèáêà. Òàêîå áûâàåò. Âû õîòåëè âûçâàòü:\n\n"

                  "txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()\n\n"

                  "Õîòü âû äîëãî [êîïèðîâàëè]íàáèðàëè ýòî èìÿ, íà ñàìîì äåëå ýòà ôóíêöèÿ íå ðåàëèçîâàíà. "
                  "Åñòü äðóãàÿ ôóíêöèÿ, êîòîðàÿ óáèðàåò àâòî-ïàóçó â êîíöå ïðîãðàììû, íî â õåëïå ïðî íåå íå íàïèñàíî.\n\n"

                  "Íî íå âñå òàê ïëîõî. Îïðåäåëåíèå íóæíîé ôóíêöèè åñòü â èñõîäíûõ òåêñòàõ TXLib.h, îíî ëåæèò ðÿäîì "
                  "ñ îïðåäåëåíèåì òîé ôóíêöèè ñ äëèííûì íàçâàíèåì, êîòîðóþ âû ñåé÷àñ âûçâàëè.\n\n"

                  "Íàæìèòå â ðåäàêòîðå Ctrl+O, íàéäèòå è îòêðîéòå ôàéë TXLib.h (îí ëåæèò â ïàïêå, êóäà âû "
                  "óñòàíîâèëè TXLib), çàòåì íàæìèòå Ctrl+F è èùèòå \"txIDontWant\". Óäà÷è!\n\n",

                  "Íå ïîëó÷èëîñü", MB_ICONSTOP);

    // The truth is out there... (C++files)

    return false;
    }

//-----------------------------------------------------------------------------------------------------------------

// Bingo! Now you are learned to use the Sources, Luke. And may the Source be with you.

inline bool txDisableAutoPause()
    {
    _txExit = true;
    return true;
    }

// P.S. This library contains more undocumented functions. Search them via "Luke" keyword.

//-----------------------------------------------------------------------------------------------------------------

void _txDump (const void* address, const char name[] /*= "_txDump()"*/, bool pause /*= true*/)
    {
$1  assert (!_txIsBadReadPtr (address));

    const unsigned char* p = (const unsigned char*) address;
$   unsigned x = 0;

$   unsigned attr = txGetConsoleAttr();

$   txSetConsoleAttr (FOREGROUND_WHITE);
$   printf ("\n%*.*s ", (int) sizeof (address) * 2, (int) sizeof (address) * 2, ((name)? name : ""));

$   txSetConsoleAttr (FOREGROUND_YELLOW);
$   for (x = 0; x < 16; x++) printf ("%02X ", x);
$   for (x = 0; x < 16; x++) printf ("%X",    x);

$   const char   isCtrl[] = "\a" "\b" "\n" "\r" "\t" "\0";
$   const char   xlatCh[] =  "·"  "·"  "·"  "·"  "·"  "·";
$   const size_t szCtrl   = sizeof (isCtrl) - 1;

$   int oldCP = GetConsoleOutputCP();

$   for (int y = 0; y < 16; y++, p += 16)
        {
        txSetConsoleAttr (FOREGROUND_YELLOW);

        printf ("\n" "%*p ", (int) sizeof (address) * 2, p);

        int color = FOREGROUND_LIGHTGREEN;

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);
            printf ("%02X ", p[x]);
            }

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);

            char c = p[x];
            const char* ctrl = (const char*) memchr (isCtrl, c, szCtrl);
            if (ctrl) c = xlatCh [ctrl - isCtrl];

            if (ctrl) SetConsoleOutputCP (1251);

            printf ("%c", c);

            if (ctrl) SetConsoleOutputCP (oldCP);
            }
        }

$   txSetConsoleAttr (attr);
$   printf ("\n");

$   if (pause)
        {
$       SetConsoleOutputCP (_TX_CODEPAGE);

$       fprintf (stderr, "[Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]                          CodePage = %5d\n", oldCP);
$       (void)_getch();

$       SetConsoleOutputCP (oldCP);
        }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txStackBackTrace (const char file[] /*= "?"*/, int line /*= 0*/, const char func[] /*= "?"*/,
                        bool readSource /*= true*/)
    {
$1  unsigned attr = txGetConsoleAttr();
$   txSetConsoleAttr (FOREGROUND_LIGHTCYAN);

$   fprintf (stderr, "\n" "--------------------------------------------------\n"
                          "Òðàññèðîâêà ñòåêà èç \"%s\" at %s (%d):\n\n"
                          "%s\n\n"
                          "--------------------------------------------------\n\n",
                          func, file, line, _txCaptureStackBackTrace (1, readSource));

$   txSetConsoleAttr (attr);
    }

//-----------------------------------------------------------------------------------------------------------------

char* txDemangle (const char* mangledName, std::nomeow_t)
    {
$1  if (!mangledName) return NULL;

$   char* typeName = NULL;

    #if defined (_GCC_VER)

$   int err = 1;
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err); (void) err;
    if (typeName) {$ return typeName; }

    #endif

$   unsigned short flags = 0;

$   if (mangledName[0] == '.')
        {
$       mangledName++;
$       flags = 0x2800;  // UNDNAME_32_BIT_DECODE | UNDNAME_TYPE_ONLY
        }

$   typeName = _TX_CALL (Win32::__unDName, (NULL, mangledName, 0, malloc, free, flags));
    if (typeName) {$ return typeName; }

$   return _strdup (mangledName);
    }

//-----------------------------------------------------------------------------------------------------------------

std::string txDemangle (const char* mangledName)
    {
$1  char* typeName = txDemangle (mangledName, std::nomeow);
$   std::string name (typeName? typeName : "");
$   free (typeName);

$   return name;
    }

//-----------------------------------------------------------------------------------------------------------------

double txQueryPerformance()
    {
$1  int maxTime    =  500;
$   int maxSamples =  100;
$   POINT size     = {100, 100};

$   HDC dc = _txBuffer_Create (txWindow(), &size, NULL);
$   assert (dc); if (!dc) return -1;

$   DWORD mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), 1);
$   assert (mask);

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   int samples = 0;
$   while (samples++ < maxSamples)
        {
$       LARGE_INTEGER cur = {};
$       QueryPerformanceCounter (&cur) asserted;

$       double t = 1000.0 * (double) (cur.QuadPart - start.QuadPart) / (double) freq.QuadPart;
$       if (t > maxTime) break;

        // Draw test scene

$       for (int y = 0; y < size.y; y++)
        for (int x = 0; x < size.x; x++)     txSetPixel (x, y, TX_BLACK, dc);

$       for (int y = 0; y < size.y; y += 10)
        for (int x = 0; x < size.x; x += 50) txTextOut  (x, y, "*", dc);

$       txEllipse (0, 0, size.x, size.y, dc);
$       txFloodFill (size.x/2, size.y/2, TX_TRANSPARENT, FLOODFILLSURFACE, dc);

$       txBitBlt (dc, size.x/2,        0, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc,        0, size.y/2) asserted;
$       txBitBlt (dc,        0, size.y/2, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, size.x/2,        0) asserted;
        }

$   mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), mask);
$   assert (mask);

$   _txBuffer_Delete (&dc);

$   return 3.0 * samples / sqrt (1.0 * size.x * size.y);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_TX_CPP11)
template <int txFramesToAverage>
#endif

double txGetFPS (int minFrames)
    {
$1  static LARGE_INTEGER time0 = {}; if (!time0.QuadPart) QueryPerformanceCounter (&time0);
$          LARGE_INTEGER time  = {};                      QueryPerformanceCounter (&time);

$   if (time.QuadPart - time0.QuadPart == 0)
        {$ return 0; }

$   LARGE_INTEGER freq = {}; QueryPerformanceFrequency (&freq);

$   double fps = (double) freq.QuadPart / (double) (time.QuadPart - time0.QuadPart);
$   time0 = time;

$   if (txFramesToAverage == 0) return fps;

$   static double average [txFramesToAverage] = {};
$   static unsigned n = 0;

$   average [n++ % txFramesToAverage] = fps;

$   unsigned nn = MIN (n, (unsigned) sizearr (average));

$   static double median  [txFramesToAverage] = {};
$   std::copy (average, average + nn, median);
$   std::nth_element (median, median + nn/2, median + nn);

$   fps = (median [(nn-1) / 2] + median [nn / 2]) / 2.0;

$   return ((int)n >= MIN (minFrames, txFramesToAverage))? fps : 0;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txExtractColor (COLORREF color, COLORREF component)
    {
$1  switch (component)
        {
        case TX_RED:
        case TX_HUE:        $ return (color >>  0) & 0xFF;

        case TX_GREEN:
        case TX_SATURATION: $ return (color >>  8) & 0xFF;

        case TX_BLUE:
        case TX_LIGHTNESS:  $ return (color >> 16) & 0xFF;

        default:            $ return CLR_INVALID;
        }
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txRGB2HSL (COLORREF rgbColor)
    {
$1  int r = (int) txExtractColor (rgbColor, TX_RED),
        g = (int) txExtractColor (rgbColor, TX_GREEN),
        b = (int) txExtractColor (rgbColor, TX_BLUE);

$   double m1 = MAX (MAX (r, g), b) / 255.0,
           m2 = MIN (MIN (r, g), b) / 255.0,
           dm = m1 - m2,
           sm = m1 + m2,

           ir = r / 255.0,
           ig = g / 255.0,
           ib = b / 255.0,

           ih = 0,
           is = 0,
           il = sm / 2;

$   const double prec = 0.001;

$   if (fabs (dm) < prec)
        {
$       is = dm / ((sm <= 1)? sm : (2-sm));

$       double cr = (m1 - ir) / dm,
               cg = (m1 - ig) / dm,
               cb = (m1 - ib) / dm;

$       if (fabs (ir - m1) < prec) ih =     cb - cg;
$       if (fabs (ig - m1) < prec) ih = 2 + cr - cb;
$       if (fabs (ib - m1) < prec) ih = 4 + cg - cr;
        }

$   ih = (ih >= 0)? ih*60 : ih*60 + 360;

$   return RGB (ROUND (ih / 360 * 255), ROUND (is * 255), ROUND (il * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txHSL2RGB (COLORREF hslColor)
    {
$1  struct xRGB
        {
        static double calc (double h, double m1, double m2)
            {
$           if (h < 0)   h += 360;
$           if (h > 360) h -= 360;

$           return (h <  60)? m1 + (m2-m1) *      h  / 60 :
                   (h < 180)? m2 :
                   (h < 240)? m1 + (m2-m1) * (240-h) / 60 :
                              m1;
            }
        };

$   int h = (int) txExtractColor (hslColor, TX_HUE),
        s = (int) txExtractColor (hslColor, TX_SATURATION),
        l = (int) txExtractColor (hslColor, TX_LIGHTNESS);

$   double ih = h / 255.0 * 360.0,
           il = l / 100.0,
           is = s / 100.0,

           m2 = (il <= 0.5)? il * (1 + is) : il + is - il * is,
           m1 = 2 * il - m2,

           ir = s? xRGB::calc (ih + 120, m1, m2) : il,
           ig = s? xRGB::calc (ih,       m1, m2) : il,
           ib = s? xRGB::calc (ih - 120, m1, m2) : il;

$   return RGB (ROUND (ir * 255), ROUND (ig * 255), ROUND (ib * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (std::nomeow_t, double left, double right)
    {
    return left + (right - left) * ((double) rand() / RAND_MAX);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (std::nomeow_t, Tx x, Ta a, Tb b)
    {
    return a <= x && x <= b;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int random (int range)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return rand() % range;
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (double left, double right)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return random (std::nomeow, left, right);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (Tx x, Ta a, Tb b)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return In (std::nomeow, x, a, b);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const POINT& pt, const RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.x, rect.left, rect.right) &&
           In (std::nomeow, pt.y, rect.top,  rect.bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const COORD& pt, const SMALL_RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.X, rect.Left, rect.Right) &&
           In (std::nomeow, pt.Y, rect.Top,  rect.Bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

void tx_fpreset()
    {
$1  txAutoLock _lock;

$   Win32::_fpreset();

$   unsigned new87 = 0x0008001C;  // _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW

    #if !defined (__CYGWIN__)

$   unsigned old87 = 0;
$   if (_controlfp_s (&old87, 0, 0) == 0)
        {$ (void) _controlfp_s (&old87, old87  & ~new87, 0x0008001F); }  // _MCW_EM

    #else

$   Win32::_controlfp (Win32::_controlfp (0, 0) & ~new87, 0x0008001F);    // _MCW_EM

    #endif
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T zero() { T __zero = {}; return __zero; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txPrintf() implementation
//           Ðåàëèçàöèÿ txPrintf()
//=================================================================================================================

#if defined (_TX_CPP11)

template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                                  const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width,                   const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                precision_t prec, const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args);
                                         void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt);

template <typename T>                    void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int*     arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt);

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg, ArgsT... args)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*') {$ stream << std::setw (width); }
    else {$ TX_ERROR ("\"%%*\" required to setwidth (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '*') {$ stream << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%.*\" required to setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*' && fmt[2] == '.' && fmt[3] == '*') {$ stream << std::setw (width) << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%*.*\" required to setwidth (%d) and setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (!fmt[0]) {$}
    else {$ TX_ERROR ("No argument provided for %% in \"%s\" while printing \"%s\"", fmt, format); }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char*, int, const char*& fmt)
    {
$1  assert (&stream);
$   assert (fmt);

$   while (*fmt)
        {
        if (fmt[0] == '%')
            {
            if (fmt[1] == '%') fmt++;
            else break;
            }

        stream << *fmt++;
        }
$   }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg)
    {
$1  assert (&stream);
$   assert (fmt);

$   if (_TX_ARGUMENT_FAILED (&arg)) return;

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   fmt++;

$   char                    oldFill  = stream.fill (' ');
$   std::ios_base::fmtflags oldFlags = stream.flags();

$   for (;;) switch (*fmt)
        {
        case '-': $ stream << std::left;     fmt++; break;
        case '+': $ stream << std::showpos;  fmt++; break;
        case ' ': $ stream.fill (' ');       fmt++; break;
        case '#': $ stream << std::showbase; fmt++; break;
        case '0': $ stream.fill ('0');       fmt++; break;

        default:  $ goto end;
        }
    end:

$   int width = (*fmt != '*')?                  (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0);
$   int prec  = (*fmt == '.')? (*++fmt != '*')? (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0) : 0;

    if (width) {$ stream << std::setw (width);        }
    if (prec)  {$ stream << std::setprecision (prec); }

$   fmt += strspn (fmt, "hljztL");

$   switch (*fmt)
        {
        case '$':
        case '?': $                                              break;

        case 'd':
        case 'i':
        case 'u': $ stream << std::dec;                          break;

        case 'o': $ stream << std::oct;                          break;

        case 'x': $ stream << std::hex;                          break;
        case 'X': $ stream << std::hex        << std::uppercase; break;

        case 'f': $ stream << std::fixed;                        break;
        case 'F': $ stream << std::fixed      << std::uppercase; break;

        case 'e': $ stream << std::scientific;                   break;
        case 'E': $ stream << std::scientific << std::uppercase; break;

        case 'g': $                                              break;
        case 'G': $ stream                    << std::uppercase; break;

        case 'a': $                                              break;
        case 'A': $ stream                    << std::uppercase; break;

        case 'c':
        case 's':
        case 'p': $                                              break;

        default:  $ TX_ERROR ("Invalid format '%.1s' at \"%s\" while printing %s argument %d in \"%s\"", fmt, fmt, txTypename (arg), n, format); break;
        }

$   fmt++;

    if (&arg) {$ stream << arg;      }
    else      {$ stream << "(null)"; }

$   stream.fill  (oldFill);
$   stream.flags (oldFlags);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int* arg)
    {
$1  assert (fmt);

    if (_TX_ARGUMENT_FAILED (arg)) return;

    if (fmt[0] == '%' && fmt[1] == 'n') {$}
    else {$ TX_ERROR ("\"%%n\" required to store print length in int* argument %d in \"%s\"", n, format); }

$   *arg = (int) stream.str().length();

$   fmt += 2;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T> inline const T&    _txPrintfNormalizeArg (const T&           arg) { if (_TX_ARGUMENT_FAILED (&arg)) {;}          return arg;         }
                      inline const char* _txPrintfNormalizeArg (const std::string& arg) { if (_TX_ARGUMENT_FAILED (&arg)) return NULL; return arg.c_str(); }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (std::ostringstream& stream, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&stream)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   const char* fmt = format;
$   _txPrintF (stream, format, 2, fmt, _txPrintfNormalizeArg (args)...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (char buffer[], size_t size, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&buffer)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   if (size > 0) size--;
$   buffer[size] = 0;

$   if (!size) return 0;

$   std::ostringstream stream;
$   stream.rdbuf() -> pubsetbuf (buffer, size);

$   txPrintf (stream, format, args...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline std::string txFormat (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return "";

$   std::ostringstream stream;

$   txPrintf (stream, format, args...);

$   return stream.str();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   return printf ("%s", txFormat (format, args...) .c_str());
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

       int _txPrintfCheck (const char* format, ...) tx_printfy (1);
inline int _txPrintfCheck (const char*,        ...) { return 0; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txDialog methods implementation
//           Ðåàëèçàöèÿ ìåòîäîâ êëàññà txDialog
//
//           See [1] http://msdn.microsoft.com/ru-ru/library/windows/desktop/ms645389%28v=vs.85%29.aspx
//               [2] http://blogs.msdn.microsoft.com/oldnewthing/20050429-00/?p=35743
//               [3] http://blogs.msdn.microsoft.com/oldnewthing/20040623-00/?p=38753
//=================================================================================================================

txDialog::txDialog () :
    layout_ (NULL)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

txDialog::txDialog (const Layout* layout) :
    layout_ (layout)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

const txDialog::Layout* txDialog::setLayout (const Layout* layout)
    {
$1  assert (layout);

$   return ::std::swap (layout_, layout), layout;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (WORD resourceID)
    {
$1  const char* resName = (char*)(uintptr_t) resourceID;

$   if (!FindResource (NULL, resName, RT_DIALOG)) return TX_DEBUG_ERROR ("Íå íàéäåí ðåñóðñ äèàëîãà %d", resourceID), 0;

$   return DialogBoxParam (NULL, resName, NULL, (DLGPROC) DialogProc_, (LPARAM) this);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (const txDialog::Layout* layout /*= NULL*/, size_t bufsize /*= 0*/)
    {
$1  if (!layout)  layout = layout_;
$   if (!layout)  return TX_DEBUG_ERROR ("Íå óñòàíîâëåí äèíàìè÷åñêèé øàáëîí äèàëîãà"), 0;

$   if (!bufsize) bufsize = 1024;

$   DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$   if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà"), 0;

$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };

$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];

$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }

$   tmpl->cdit = (unsigned short) (i-1);

$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);

$   GlobalFree (tmpl);

$   return res;
    }

//-----------------------------------------------------------------------------------------------------------------

int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;

        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;

            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }

$   return FALSE;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;

$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;

$   WORD* pw = (WORD*) globalMem;

$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;

$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }

$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   return pw;
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;

$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;

$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;

$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }

$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }

$   *pw++ = 0;

$   return pw;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================

#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$

//}
//=================================================================================================================

//! @endcond

//=================================================================================================================
//{          Experimental Debugging macros
//! @name    Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//!          âî âðåìÿ åãî âûïîëíåíèÿ.
//!
//!          Ñäåëàé ïðèÿòíûìè òâîè <i>êðóãëûå ñóòêè), MB_ICONSTOP | MB_SYSTEMMODAL | MB_YESNOCANCEL);
        }
 
    SetLastError (winErr);
 
    errno = crtErr;
 
    #if !defined (__CYGWIN__)
    _doserrno = dosErr;
    #endif
 
    if (((options & isFatal) && !IsDebuggerPresent()) || ret == IDYES)
        {
        txUnlock();
        _txCleanup();
        Win32::TerminateProcess (GetCurrentProcess(), EXIT_FAILURE);
        }
 
    #undef PRINT_
 
    return what;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_MSC_VER)
 
int _txOnErrorReport (int type, const char* text, int* ret)
    {
    assert (text);
    assert (ret);
 
    _txErrors++;
 
    unsigned restore = txGetConsoleAttr();
 
    switch (type)
       {
       case _CRT_WARN:   txSetConsoleAttr (FOREGROUND_LIGHTRED);     break;
       case _CRT_ERROR:  txSetConsoleAttr (FOREGROUND_LIGHTMAGENTA); break;
       case _CRT_ASSERT: txSetConsoleAttr (FOREGROUND_YELLOW);       break;
       default:                                                      break;
       }
 
    const char startReport[] = "Detected memory leaks!\n",
                 endReport[] = "Object dump complete.\n";
 
    if (strcmp (text, startReport) == 0)  // Dirty, dirty hack. À ÷òî äåëàòü?
        {
        _txOnErrorReport (type, "\n",                                                                              NULL);
        _txOnErrorReport (type, _TX_VERSION " - ERROR: ",                                                          NULL);
        _txOnErrorReport (type, "Âíèìàíèå: Îáíàðóæåíû óòå÷êè ïàìÿòè! (Äëÿ ïîèñêà èñïîëüçóéòå _TX_ALLOC_BREAK.)\n", NULL);
        _txOnErrorReport (type, "\n",                                                                              NULL);
        }
 
    size_t len = strlen (text);
    if (text [len-1] != '\n')               txOutputDebugPrintf ("%s",                text);
    else if (strcmp (text, endReport) != 0) txOutputDebugPrintf ("%s" "%s - ERROR: ", text, _TX_VERSION);
    else                                    txOutputDebugPrintf ("%s\n",              text);
 
    DWORD n = 0;
    HANDLE err = GetStdHandle (STD_ERROR_HANDLE);
    WriteFile (err, text, (DWORD) strlen (text), &n, NULL);
 
    txSetConsoleAttr (restore);
 
    if (*_txLogName) do
        {
        HANDLE log = CreateFile (_txLogName, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (log == INVALID_HANDLE_VALUE) break;
 
        SetFilePointer (log, 0, NULL, FILE_END);
        WriteFile (log, text, (DWORD) strlen (text), &n, NULL);
 
        CloseHandle (log);
        break;
        }
        while (false);
 
    if (ret) *ret = 0;
 
    return (type == _CRT_WARN);
    }
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
int txMessageBox (const char text[], const char header[], unsigned flags /*= MB_ICONINFORMATION | MB_OKCANCEL*/)
    {
$5  static wchar_t textW   [_TX_BIGBUFSIZE * sizeof (wchar_t)] = L"[NULL text]";
$   static wchar_t headerW [_TX_BUFSIZE    * sizeof (wchar_t)] = L"[NULL header]";
 
    if (text)   {$ MultiByteToWideChar (_TX_CODEPAGE, 0, text,   -1, textW,   sizearr (textW))   || memset (textW,   0, sizeof (textW));   }
    if (header) {$ MultiByteToWideChar (_TX_CODEPAGE, 0, header, -1, headerW, sizearr (headerW)) || memset (headerW, 0, sizeof (headerW)); }
 
$   HWND wnd = _txCanvas_Window;
$   int  ret = MessageBoxW ((wnd && IsWindowVisible (wnd))? wnd : _TX_CALL (Win32::GetConsoleWindow,()),
                            textW, headerW, flags | MB_SETFOREGROUND | MB_TOPMOST | MB_OKCANCEL );
$   if (ret == IDCANCEL)
        {
$       SendNotifyMessage (txWindow(), (_txMain? WM_CLOSE : WM_DESTROY), 0, 0);
$       _txWaitFor (!_txCanvas_Window, _TX_TIMEOUT);
        }
 
$   return ret;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txGetAsyncKeyState (int key)
    {
$1  HWND wnd = GetForegroundWindow();
 
    return (GetAsyncKeyState (key) & 0x8000) &&
           (wnd == txWindow() || wnd == Win32::GetConsoleWindow());
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txNotifyIcon (unsigned flags, const char title[], const char format[], ...)
    {
$5  if (_TX_ARGUMENT_FAILED (format)) return false;
 
$   va_list arg; va_start (arg, format);
$   bool ok = true;
 
    #if defined (_WIN32_IE) && (_WIN32_IE >= 0x0500)
 
$   NOTIFYICONDATA nid = { sizeof (nid) };
 
$   nid.uFlags      = NIF_ICON | NIF_TIP | NIF_INFO;
$   nid.hWnd        = NULL;
$   nid.uID         = 1;
$   nid.hIcon       = _txCreateTXIcon (16); assert (nid.hIcon);
$   strncpy_s       (nid.szTip,       sizeof (nid.szTip),       "TXLib Information", sizeof (nid.szTip));
$   strncpy_s       (nid.szInfoTitle, sizeof (nid.szInfoTitle), (title? title : "TXLib ñîîáùàåò"), sizeof (nid.szInfoTitle) - 1);
$   _tx_vsnprintf_s (nid.szInfo, sizeof (nid.szInfo), format, arg);
$   nid.dwInfoFlags = flags;
 
$   txOutputDebugPrintf ("\r" _TX_VERSION " - %s: %s (Icon notification)\n", nid.szInfoTitle, nid.szInfo);
 
$   ok &= !!Shell_NotifyIcon (NIM_ADD,    (::NOTIFYICONDATA*) &nid);
$   ok &= !!Shell_NotifyIcon (NIM_MODIFY, (::NOTIFYICONDATA*) &nid);
 
$   if (nid.hIcon) DestroyIcon (nid.hIcon) asserted;
 
    #else
 
$   char nid_szInfo[_TX_BUFSIZE] = "";
$   _tx_vsnprintf_s (nid_szInfo, sizeof (nid_szInfo), format, arg);
$   txOutputDebugPrintf ("\r" _TX_VERSION " - %s: %s (Icon notification - NOT displayed)\n", title, nid_szInfo);
$   ok = false;
 
$   (void)flags; (void)title;
 
    #endif
 
$   va_end (arg);
    return ok;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txTrace (const char file[], int line, const char func[], const char msg[] /*= NULL*/, ...)
    {
    unsigned id = GetCurrentThreadId();
 
    const char marks[2][2][3] = {{"uU", "cC"}, {"mM", "??"}};
 
    char mark = marks [id == _txMainThreadId] [id == _txCanvas_ThreadId] [(_txLoc::Cur.inTX > 0)];
 
    char msgStr[_TX_BUFSIZE] = "";
    if (msg)
        {
        va_list arg; va_start (arg, msg);
        _tx_vsnprintf_s (msgStr, sizeof (msgStr) - 1, msg, arg);
        va_end (arg);
        }
 
    txOutputDebugPrintf ("%s - 0x%p %c%c%c%c%c%d [%c] - %-*s (%5d)  " "|%*s%s" "%s%s\n",
 
                         _TX_VERSION, &_txInitialized,
 
                         "cC"[_txConsole], "mM"[_txMain], "dD"[_txIsDll], "rR"[_txRunning], "eE"[_txExit],
                         _txLoc::Cur.trace, mark,
 
                         (int) sizeof (__FILE__) - 1, (file? file : "(NULL file)"), line,
                         2 * (_txLoc::Cur.inTX - 1) * !!func, "", (func? func : ""),
 
                         ((*msgStr && func)? ": " : ""), msgStr);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int txOutputDebugPrintf (const char format[], ...)
    {
    if (!format) return 0;
 
    enum { msgbox = 1, print = 2, compr = 4 };
    int options = 0;
 
    for (; format && *format; format++)
        {
        if      (*format == '\a') options |= msgbox;
        else if (*format == '\f') options |= print;
        else if (*format == '\r') options |= compr;
        else break;
        }
 
    char text[_TX_BIGBUFSIZE] = "";
 
    va_list arg; va_start (arg, format);
    int n = (int) _tx_vsnprintf_s (text, sizeof (text) - 1-1, format, arg);
    va_end (arg);
 
    struct __ { static int trimSpaces (char str[])
        {
        char *dst = str, *src = str;
 
        for (char d = ' '; d; src++)
            if (isspace ((unsigned char)(*src))) { if (d != ' ') *dst++ = d = ' '; }
            else                                                 *dst++ = d = *src;
 
        return (int) (dst - str - 1);
        }};
 
    if (options & compr)  n = __::trimSpaces (text);
 
    OutputDebugString (text);
 
    if (options & print)  fprintf (stderr, "%s", text);
 
    if (options & msgbox) txMessageBox (text, "Îêàçûâàåòñÿ, ÷òî, MB_ICONEXCLAMATION);

    return n;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _tx_snprintf_s (char stream[], intptr_t size, const char format[], ...)
    {
    if (!format) return 0;

    va_list arg; va_start (arg, format);
    intptr_t ret = _tx_vsnprintf_s (stream, size, format, arg);
    va_end (arg);

    return ret;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t _tx_vsnprintf_s (char stream[], intptr_t size, const char format[], va_list arg)
    {
    if (!stream || !format) return 0;

    #if defined (_TRUNCATE)
    intptr_t ret = _vsnprintf_s (stream, size, _TRUNCATE, format, arg);
    #else
    intptr_t ret = _vsnprintf   (stream, size,            format, arg);
    #endif

    if (ret < 0 && size >= 4)
        {
        const char ellipsis[] = "...";
        size_t     szEllipsis = sizeof (ellipsis) - 1;

        strncpy_s (stream + size - szEllipsis, szEllipsis+1, ellipsis, szEllipsis);
        }

    return (ret >= 0)? ret : size;
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (__CYGWIN__)

int _getch()
    {
    termios oldattr = {}; tcgetattr (STDIN_FILENO, &oldattr);

    termios newattr = oldattr;
    newattr.c_lflag &= ~(ICANON | ECHO);
    tcsetattr (STDIN_FILENO, TCSANOW, &newattr);

    int ch = getchar();

    tcsetattr (STDIN_FILENO, TCSANOW, &oldattr);

    return ch;
    }

//-----------------------------------------------------------------------------------------------------------------

int _putch (int ch)
    {
    termios old = {}; tcgetattr (STDOUT_FILENO, &old);

    termios cur = old;
    cur.c_lflag &= ~ICANON;
    cur.c_lflag |=  ECHO;
    tcsetattr (STDOUT_FILENO, TCSANOW, &cur);

    putchar (ch);

    tcsetattr (STDOUT_FILENO, TCSANOW, &old);

    return ch;
    }

//-----------------------------------------------------------------------------------------------------------------

int _kbhit()
    {
    termios old = {}; tcgetattr (STDIN_FILENO, &old);

    termios cur = old;
    cur.c_lflag &= ~(ICANON | ECHO);
    cur.c_cc[VMIN]  = 1;
    cur.c_cc[VTIME] = 0;

    tcsetattr (STDIN_FILENO, TCSAFLUSH, &cur);

    fd_set  fd = {}; FD_SET (STDIN_FILENO, &fd);
    timeval tv = {};

    int res = select (STDIN_FILENO + 1, &fd, NULL, NULL, &tv) && FD_ISSET (STDIN_FILENO, &fd);

    tcsetattr (STDIN_FILENO, TCSAFLUSH, &old);

    return res;
    }

#endif

//}
//-----------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------------------------------------
//{          Information
//-----------------------------------------------------------------------------------------------------------------

const char* txGetModuleFileName (bool fileNameOnly /*= true*/)
    {
    static char name[MAX_PATH] = "";

    if (!*name)
        {
        if (!GetModuleFileName (NULL, name, sizeof (name) - 1)) *name = 0;

        char* ext = strrchr (name, '.');
        if (ext) _strlwr_s (ext, sizeof (name) - 1 - (ext - name));
        }

    assert (*name);

    if (fileNameOnly) return name;

    static char fullName[MAX_PATH] = "";
    strncpy_s (fullName, sizeof (fullName), name, sizeof (fullName) - 1);

    char* title = strrchr (fullName, '\\'); if (!title) title = fullName;
    char* ext   = strrchr (fullName,  '.'); if (!ext)   ext   = fullName + strlen (fullName);

    size_t sz = sizeof (fullName) - (ext - fullName);
    strncpy_s (ext, sz-1, " - TXLib", sz);

    return title + 1;
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txAppInfo()
    {
$1  time_t timeT     = time (NULL) - clock()/CLOCKS_PER_SEC;
    char   timeS[32] = "";
    ctime_s (timeS, sizeof (timeS), &timeT);

    static char text[_TX_BUFSIZE] = "";
    char cwd [MAX_PATH] = "";

    _tx_snprintf_s (text, sizeof (text) - 1,

                    "Developed with:\n\n"
                    "The Dumb Artist Library (TX Library)\n"
                    _TX_VERSION "\n" _TX_AUTHOR "\n"
                    "See license on: http://txlib.ru\n\n"

                    "TXLib file:" "\t" __FILE__ "\n"
                    "Compiled:"   "\t" __DATE__ " " __TIME__ ", " __TX_COMPILER__ ", %s, %d-bit, " _TX_BUILDMODE "\n"
                    "Started:"    "\t" "%.6s %.4s %.8s\n\n"

                    "Run file:"   "\t" "%s\n"
                    "Directory:"  "\t" "%s",

    #if   defined (_MSC_VER)
                    "MSVC Runtime",
    #elif defined (__CYGWIN__)
                    "Cygwin Runtime",
    #elif defined (_GCC_VER) && defined (_WIN64)
                    __mingw_get_crt_info(),
    #else
                    "MinGW Runtime " TX_QUOTE (__MINGW32_MAJOR_VERSION) "." TX_QUOTE (__MINGW32_MINOR_VERSION),
    #endif
                    (sizeof (void*) == sizeof (DWORD))? 32 : 64,

                    timeS + 4, timeS + 20, timeS + 11,              // These offsets are ANSI standardized
                    txGetModuleFileName(),
                    _getcwd (cwd, sizeof (cwd) - 1));

    return text;
    }

//}
//-----------------------------------------------------------------------------------------------------------------

//! @}
//}
//=================================================================================================================

//=================================================================================================================
//{          TXLib API implementation
//           Ðåàëèçàöèÿ TXLib API
//=================================================================================================================

inline const char* txVersion()
    {
    return _TX_VERSION;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txVersionNumber()
    {
    return _TX_VER;
    }

//-----------------------------------------------------------------------------------------------------------------

inline HWND txWindow()
    {
$0  return _txCanvas_Window;
    }

//-----------------------------------------------------------------------------------------------------------------

inline HDC& txDC()
    {
$0  return _txCanvas_BackBuf[0];
    }

//-----------------------------------------------------------------------------------------------------------------

inline RGBQUAD* txVideoMemory()
    {
    return _txCanvas_Pixels;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetExtent (HDC dc /*= txDC()*/)
    {
$0  static POINT err = {-1, -1};

    if (!dc) {$ POINT screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) }; return screen; };

    if (_TX_DEFAULT_HDC_FAILED (dc)) {$ return err; }

$   BITMAP bmap = {};
$   txGDI (Win32::GetObject (Win32::GetCurrentObject (dc, OBJ_BITMAP), sizeof (bmap), &bmap), dc) asserted;

$   POINT  size = { bmap.bmWidth, bmap.bmHeight };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetExtentX (HDC dc /*= txDC()*/)
    {
    return txGetExtent (dc) .x;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetExtentY (HDC dc /*= txDC()*/)
    {
    return txGetExtent (dc) .y;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDestroyWindow (HWND wnd /*= txWindow()*/)
    {
$1  if (!wnd || !txWindow()) return false;

$   if (wnd != txWindow())
        {
$       return !!SendNotifyMessage (txWindow(), _TX_WM_DESTROYWND, 0, (LPARAM) wnd);
        }

$   if (SendNotifyMessage (txWindow(), (_txMain? WM_CLOSE : WM_DESTROY), 0, 0) == 0) return false;

$   if (_txMain)
        {
$       txNotifyIcon (NIIF_WARNING, NULL, "\n" "Î÷åíü, î÷åíü ïëîõî çàâåðøàòü ïðîãðàììó ÷åðåç txDestroyWindow().\n\n"
                                               "Âîçâðàùàéòåñü ÷åðåç main(), òàì âàì áóäóò ðàäû.\n");
$       Sleep (_TX_TIMEOUT);
        }

$   _txWaitFor (!_txCanvas_Window, _TX_TIMEOUT);

$   return _txCanvas_Window == NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

HPEN txSetColor (COLORREF color, double thickness /*= 1*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return NULL;

$   HPEN pen = Win32::CreatePen ((color == TX_TRANSPARENT? PS_NULL : PS_SOLID), ROUND (thickness), color);

$   if (!pen) return (HPEN) NULL;

$   if (!_txBuffer_Select (pen, dc))
        {
$       Win32::DeleteObject (pen);
$       return (HPEN) NULL;
        }

$   if (txGDI (Win32::SetTextColor (dc, color), dc) == CLR_INVALID)
        {$ return (HPEN) NULL; }

$   return pen;
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txColor (double red, double green, double blue)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;

$   COLORREF color = RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255));

$   return txSetColor (color)? color : CLR_INVALID;
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txGetColor (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;

$   HGDIOBJ obj = txGDI ((Win32::GetCurrentObject (dc, OBJ_PEN)), dc);
$   assert (obj); if (!obj) return CLR_INVALID;

$   union { EXTLOGPEN extLogPen; LOGPEN LogPen; } buf = {};

$   int size = Win32::GetObject (obj, 0, NULL);
$   Win32::GetObject (obj, sizeof (buf), &buf) asserted;

$   return (size == sizeof (LOGPEN))? buf.LogPen.lopnColor : buf.extLogPen.elpColor;
    }

//-----------------------------------------------------------------------------------------------------------------

HBRUSH txSetFillColor (COLORREF color, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return NULL;

$   HBRUSH brush = (color == TX_TRANSPARENT)? (HBRUSH) Win32::GetStockObject (HOLLOW_BRUSH) : Win32::CreateSolidBrush (color);

$   return (_txBuffer_Select (brush, dc))? brush : (Win32::DeleteObject (brush), (HBRUSH) NULL);
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txFillColor (double red, double green, double blue)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;

$   COLORREF color = RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255));

$   return txSetFillColor (color)? color : CLR_INVALID;
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txGetFillColor (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;

$   HGDIOBJ obj = txGDI ((Win32::GetCurrentObject (dc, OBJ_BRUSH)), dc);
$   assert (obj); if (!obj) return CLR_INVALID;

$   LOGBRUSH buf = {};
$   txGDI ((Win32::GetObject (obj, sizeof (buf), &buf)), dc) asserted;

$   return buf.lbColor;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClear (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT size = txGetExtent (dc);
$   return txGDI (!!(Win32::PatBlt (dc, 0, 0, size.x, size.y, PATCOPY)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txSetPixel (double x, double y, COLORREF color, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   txGDI ((Win32::SetPixel (dc, ROUND (x), ROUND (y), color)), dc);

$   return true;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txPixel (double x, double y, double red, double green, double blue, HDC dc /*= txDC()*/)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;

$   return txSetPixel (x, y, RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

inline COLORREF txGetPixel (double x, double y, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;

$   return txGDI ((Win32::GetPixel (dc, ROUND (x), ROUND (y))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLine (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   bool ok  = txGDI ((Win32::MoveToEx (dc, ROUND (x0), ROUND (y0), NULL)), dc);
$        ok &= txGDI ((Win32::LineTo   (dc, ROUND (x1), ROUND (y1)      )), dc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txRectangle (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   return txGDI ((Win32::Rectangle (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPolygon (const POINT points[], int numPoints, HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (points)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))     return false;

$   return txGDI (!!(Win32::Polygon (dc, points, numPoints)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txEllipse (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   return txGDI ((Win32::Ellipse (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txCircle (double x, double y, double r)
    {
$1  return txEllipse (x-r, y-r, x+r, y+r);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txArc (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };

$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;

$   return txGDI (!!(Win32::Arc (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                     ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                     ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPie (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };

$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;

$   return txGDI (!!(Win32::Pie (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                     ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                     ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txChord (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };

$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;

$   return txGDI (!!(Win32::Chord (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                       ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                       ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txFloodFill (double x, double y,
                  COLORREF color /*= TX_TRANSPARENT*/, DWORD mode /*= FLOODFILLSURFACE*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   if (color == TX_TRANSPARENT) color = txGetPixel (x, y, dc);

$   return txGDI (!!(Win32::ExtFloodFill (dc, ROUND (x), ROUND (y), color, mode)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextOut (double x, double y, const char text[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (text)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return false;

$   int len = (int) strlen (text);
$   bool ok = txGDI (!!(Win32::TextOut (dc, ROUND (x), ROUND (y), text, len)), dc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDrawText (double x0, double y0, double x1, double y1, const char text[],
                 unsigned format /*= DT_CENTER | DT_VCENTER | DT_WORDBREAK | DT_WORD_ELLIPSIS*/,
                 HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (text)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return false;

#if !defined (NDEBUG)

$   if (x0 > x1)
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïàðàìåòð x0 = %lg áîëüøå, ÷åì x1 = %lg. Òåêñò âûâîäèòüñÿ íå áóäåò.", x0, x1);
        }

$   if (y0 > y1)
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïàðàìåòð y0 = %lg áîëüøå, ÷åì y1 = %lg. Òåêñò âûâîäèòüñÿ íå áóäåò.", y0, y1);
        }

#endif

$   RECT r = { ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1) };

$   if (!strchr (text, '\n')) format |= DT_SINGLELINE;

$   unsigned prev = txSetTextAlign (TA_LEFT | TA_TOP | TA_NOUPDATECP, dc);

$   bool ok = false;

$   if (Win32::DrawText)
        {
$       ok = !!txGDI ((Win32::DrawText (dc, text, -1, &r, format)), dc);
$       Win32::GetPixel (dc, 0, 0);
$       ok = true;
        }
    else
        {
$       txTextOut ((x0 + x1) / 2, (y0 + y1) / 2, text);
$       ok = false;
        }

$   txSetTextAlign (prev, dc);

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

HFONT txSelectFont (const char name[], double sizeY, double sizeX /*= -1*/,
                    int bold /*= FW_DONTCARE*/, bool italic /*= false*/, bool underline /*= false*/,
                    bool strikeout /*= false*/, double angle /*= 0*/,
                    HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (name)) return NULL;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return NULL;

$   HFONT font = txFontExist (name)?
                     Win32::CreateFont (ROUND (sizeY), ROUND ((sizeX >= 0)? sizeX : sizeY/3),
                                        ROUND (angle*10), 0, bold, italic, underline, strikeout,
                                        RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                        DEFAULT_QUALITY, DEFAULT_PITCH, name)
                     :
                     (HFONT) Win32::GetStockObject (SYSTEM_FIXED_FONT);

$   _txBuffer_Select (font, dc);

$   return font;
    }

//-----------------------------------------------------------------------------------------------------------------

SIZE txGetTextExtent (const char text[], HDC dc /*= txDC()*/)
    {
$1  SIZE size = {-1, -1};

$   if (_TX_ARGUMENT_FAILED    (text)) return size;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return size;

$   size_t len = strlen (text);
$   txGDI ((Win32::GetTextExtentPoint32 (dc, text, (int) len, &size)), dc) asserted;

$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetTextExtentX (const char text[], HDC dc /*= txDC()*/)
    {
$1  return txGetTextExtent (text, dc) .cx;
    }

//-----------------------------------------------------------------------------------------------------------------

int txGetTextExtentY (const char text[], HDC dc /*= txDC()*/)
    {
$1  return txGetTextExtent (text, dc) .cy;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetTextAlign (unsigned align /*= TA_CENTER | TA_BASELINE*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;

$   return txGDI ((Win32::SetTextAlign (dc, align)), dc);
    }

//-----------------------------------------------------------------------------------------------------------------

LOGFONT* txFontExist (const char name[])
    {
$1  if (_TX_ARGUMENT_FAILED (name)) return NULL;

$   static LOGFONT font = {};
$   font.lfCharSet = DEFAULT_CHARSET;
$   strncpy_s (font.lfFaceName, sizeof (font.lfFaceName), name, sizeof (font.lfFaceName) - 1);

$   struct tools
        {
        static int CALLBACK enumFonts (const LOGFONT* fnt, const TEXTMETRIC*, DWORD, LPARAM data)
            {
$           if (_TX_ARGUMENT_FAILED (fnt))  return 0;
$           if (_TX_ARGUMENT_FAILED (data)) return 0;

            #ifndef __STRICT_ANSI__
$           return _strnicmp (fnt->lfFaceName, ((LOGFONT*)data)->lfFaceName, LF_FACESIZE);

            #else
$           return  strncmp  (fnt->lfFaceName, ((LOGFONT*)data)->lfFaceName, LF_FACESIZE);

            #endif
            }
        };

$   return txGDI ((Win32::EnumFontFamiliesEx (NULL, &font, tools::enumFonts, (LPARAM) &font, 0)), NULL) == 0? &font : NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSelectObject (HGDIOBJ obj, HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (obj)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))  return false;

$   return _txBuffer_Select (obj, dc);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txCreateCompatibleDC (double sizeX, double sizeY, HBITMAP bitmap /*= NULL*/)
    {
$1  POINT size = { ROUND (sizeX), ROUND (sizeY) };

$   HDC dc = _txBuffer_Create (NULL, &size, bitmap);
$   assert (dc); if (!dc) return NULL;

$   txSetDefaults (dc);

$   if (!_txCanvas_UserDCs) return dc;

$   txAutoLock _lock;
$   _txCanvas_UserDCs->push_back (dc);

$   if (_txCanvas_UserDCs->size() >= _TX_BUFSIZE)
        {$ txNotifyIcon (NIIF_WARNING, NULL, "Âû çàãðóçèëè óæå %d HDC, ñèñòåìå ìîæåò ñòàòü ïëîõî.", (int) _txCanvas_UserDCs->size()); }

$   return dc;
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txCreateDIBSection (double sizeX, double sizeY, RGBQUAD** pixels /*= NULL*/)
    {
$1  RGBQUAD* buf = NULL;
$   if (!pixels) pixels = &buf;

$   BITMAPINFO info = {{ sizeof (info), ROUND (sizeX), ROUND (sizeY), 1, WORD (sizeof (RGBQUAD) * 8), BI_RGB }};

$   HDC dc = txCreateCompatibleDC (0, 0, Win32::CreateDIBSection (NULL, &info, DIB_RGB_COLORS, (void**) pixels, NULL, 0));

$   RGBQUAD black = { 0, 0, 0, 255 };
$   for (int i = 0; i < sizeX * sizeY; i++) (*pixels)[i] = black;

$   return dc;
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txCreateDIBSection (double sizeX, double sizeY, COLORREF** pixels)
    {
$1  return txCreateDIBSection (sizeX, sizeY, (RGBQUAD**) pixels);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txLoadImage (const char filename[], unsigned imageFlags /*= IMAGE_BITMAP*/, unsigned loadFlags /*= LR_LOADFROMFILE*/)
    {
$1  if (_TX_ARGUMENT_FAILED (filename && *filename)) return NULL;

$   HBITMAP image = (HBITMAP) Win32::LoadImage ((loadFlags & LR_LOADFROMFILE)? NULL : GetModuleHandle (NULL),
                                                 filename, imageFlags, 0, 0, loadFlags);
$   if (!image) return NULL;

$   HDC dc = txCreateCompatibleDC (0, 0, image);

$   if (!(loadFlags & LR_LOADFROMFILE)) return dc;

$   static std::map <std::string, unsigned> loadTimes;
$   std::string file = filename;
$   unsigned time    = GetTickCount();

$   if ((long) (time - loadTimes [file]) < _TX_TIMEOUT)
        {$ txNotifyIcon (NIIF_WARNING, NULL, "Âû çàãðóæàåòå \"%s\" ñëèøêîì ÷àñòî, ïðîãðàììà áóäåò òîðìîçèòü.", filename); }

$   loadTimes [file] = time;

$   return dc;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDeleteDC (HDC* pdc)
    {
$1  if (_TX_ARGUMENT_FAILED (pdc)) return false;

$   HDC  dc = *pdc;
$   bool ok = _txBuffer_Delete (pdc);
$   if (!ok) return false;

$   if (!_txCanvas_UserDCs) return ok;

$   txAutoLock _lock;
$   std::vector <HDC> ::iterator it = std::find (_txCanvas_UserDCs->begin(), _txCanvas_UserDCs->end(), dc);
$   if  (it != _txCanvas_UserDCs->end()) { std::swap (*it, _txCanvas_UserDCs->back()); _txCanvas_UserDCs->pop_back(); }

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txDeleteDC (HDC dc)
    {
$1  return txDeleteDC (&dc);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txBitBlt (HDC destImage,   double xDest, double yDest, double width, double height,
               HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, unsigned operation /*= SRCCOPY*/)
    {
$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;

$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;

$   return txGDI (!!(Win32::BitBlt (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                    sourceImage, ROUND (xSource), ROUND (ySource), operation)), destImage);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txBitBlt (double xDest, double yDest, HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txBitBlt (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTransparentBlt (HDC destImage,   double xDest, double yDest, double width, double height,
                       HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, COLORREF transColor /*= TX_BLACK*/)
    {
$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;

$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;

#if !defined (NDEBUG)

$   if (!(0 <= xSource && xSource + width  <= size.x &&
          0 <= ySource && ySource + height <= size.y))
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïðÿìîóãîëüíèê êîïèðóåìîé îáëàñòè {%lg, %lg, %lg, %lg} íå ïîëíîñòüþ ëåæèò âíóòðè èçîáðàæåíèÿ-èñòî÷íèêà {%d, %d, %d, %d}, "
                  "ôóíêöèÿ txTransparentBlt() ðàáîòàòü íå áóäåò.", xSource, ySource, xSource + width, ySource + height, 0, 0, (int) size.x, (int) size.y);
        }

#endif

$   bool ok = (Win32::TransparentBlt != NULL);

$   if (ok)
        {
$       ok &= txGDI (!!(Win32::TransparentBlt (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                               sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), transColor)),
                                               destImage);
        }
    else
        {
$       ok &= txGDI (!!(Win32::BitBlt         (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                               sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                               destImage);
        }

    return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txTransparentBlt (double xDest, double yDest, HDC sourceImage,
                              COLORREF transColor /*= TX_BLACK*/, double xSource /*= 0*/, double ySource /*= 0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txTransparentBlt (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, transColor);
    }

//-----------------------------------------------------------------------------------------------------------------

bool txAlphaBlend (HDC destImage,   double xDest, double yDest, double width, double height,
                   HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
    // Ýòî ïðîâåðêè òîãî, ïðàâèëüíûå ëè HDC âû ïåðåäàëè â ôóíêöèþ.
    // Íå áîéòåñü äîëëàðîâ - <s>ýòî íå çàïðåùåííàÿ âàëþòà</s> ýòî ìàêðîñû äëÿ îòëàäêè TXLib'à.

$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;

    // Ýòî àâòîìàòè÷åñêîå îïðåäåëåíèå ðàçìåðîâ êàðòèíêè (òî÷íåå, HDC èñòî÷íèêà - source) ñ ïîìîùüþ txGetExtent().

$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;

    // Ýòî ïðîâåðêà òîãî, ÷òî êàðòèíêà (èëè åå ÷àñòü) ïðàâèëüíî ïîïàäàåò â îêíî (òî÷íåå, HDC ïðèåìíèêà - destination, dest).
    // Åñëè îíà "âûëåçàåò" èç îêíà â ëþáóþ ñòîðîíó, òî Win32::AlphaBlend íå áóäåò ðàáîòàòü. Ýòà ïðîâåðêà ïðîèñõîäèò òîëüêî
    // â ðåæèìå îòëàäêè (êîãäà íå çàäàí ìàêðîñ NDEBUG - No Debugging, áåç îòëàäêè).

#if !defined (NDEBUG)

$   if (!(0 <= xSource && xSource + width  <= size.x &&
          0 <= ySource && ySource + height <= size.y))
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïðÿìîóãîëüíèê êîïèðóåìîé îáëàñòè {%lg, %lg, %lg, %lg} íå ïîëíîñòüþ ëåæèò âíóòðè èçîáðàæåíèÿ-èñòî÷íèêà {%d, %d, %d, %d}, "
                  "ôóíêöèÿ txAlphaBlend() ðàáîòàòü íå áóäåò.", xSource, ySource, xSource + width, ySource + height, 0, 0, (int) size.x, (int) size.y);
        }

#endif

    // Ýòî íà ñëó÷àé, åñëè ïàðàìåòð alpha âûëåçàåò çà äèàïàçîí [0..1].

$   if (alpha < 0) alpha = 0;
$   if (alpha > 1) alpha = 1;

    // Îá ýòîì ñì. íèæå.

$   BITMAP bmap = { 0, 0, 0, 0, 0, 24 };
$   bool ok = !!Win32::GetObject (txGDI ((Win32::GetCurrentObject (sourceImage, OBJ_BITMAP)), sourceImage), sizeof (bmap), &bmap);

    //
    // * Ñòðóêòóðà BLENDFUNCTION *
    //
    // Ýòà ñòðóêòóðà îïðåäåëÿåò, êàê öâåòà ïèêñåëåé îêíà (òî÷íåå, source DC) è êàðòèíêè ñìåøèâàþòñÿ ïðè ðèñîâàíèè ñ ó÷åòîì
    // ïðîçðà÷íîñòè.
    //
    // Ïàðàìåòðû ñìåøèâàíèÿ ïîìåùàþòñÿ â ãðóïïó èç ïåðåìåííûõ - òàê íàçûâàåìóþ ñòðóêòóðó. Ïåðåìåííûå, âõîäÿùèå â ñòðóêòóðó,
    // íàçûâàþòñÿ êîìïîíåíòàìè ñòðóêòóðû.
    //
    //  ýòîé ñòðóêòóðå áîëåå âñåõ âàæåí åå òðåòèé êîìïîíåíò (ñì. íèæå), çàäàþùèé ïðîçðà÷íîñòü êàðòèíêè.
    // Åñëè îí ðàâåí íóëþ - òî êàðòèíêà áóäåò ñ÷èòàòüñÿ ïîëíîñòüþ ïðîçðà÷íîé è âûçîâ Win32::AlphaBlend íè÷åãî íå íàðèñóåò.
    // Åñëè îí ðàâåí 255  - òî êàðòèíêà ñêîïèðóåòñÿ â îêíî ïîëíîñòüþ, áåç ýôôåêòà ïðîçðà÷íîñòè.
    //
    // Ñ ïîìîùüþ ÷åòâåðòîãî êîìïîíåíòà ñòðóêòóðû ñèñòåìà ðèñîâàíèÿ Windows (Win32 GDI) óçíàåò, íàäî ëè ó÷èòûâàòü àëüôà-êàíàë
    // â êîïèðóåìîé êàðòèíêå èëè åãî íàäî èãíîðèðîâàòü. Åñëè â êàðòèíêå ôàêòè÷åñêè åñòü ïðàâèëüíî ïîñòðîåííûé àëüôà-êàíàë
    // (ñì. îïèñàíèå ôóíêöèè txAlphaBlend â ñèñòåìå ïîìîùè TXLib), òî ÷åòâåðòûé êîìïîíåíò ñòðóêòóðû íàäî çàäàòü êàê êîíñòàíòó
    // AC_SRC_ALPHA.
    //
    // Åñëè â êàðòèíêå àëüôà-êàíàëà ôàêòè÷åñêè íåò, òî ÷åòâåðòûé ïàðàìåòð íàäî óñòàíîâèòü â 0.
    //
    //  êîäå íèæå ÷åòâåðòûé ïàðàìåòð îïðåäåëÿåòñÿ àâòîìàòè÷åñêè èç âûçîâà Win32::GetObject(), äëÿ óíèâåðñàëüíîñòè ïðèìåíåíèÿ
    // ôóíêöèè txAlphaBlend().
    //
    // Ïîæàëóéñòà, íå íàäî áåçäóìíî êîïèðîâàòü ñåáå â ïðîãðàììó ýòîò êîä. Îñìûñëèòå åãî, è ðåøèòå, áóäåòå ëè âû èñïîëüçîâàòü
    // àëüôà-êàíàë èëè íåò, è óñòàíîâèòå ÷åòâåðòûé ïàðàìåòð ñòðóêòóðû ëèáî AC_SRC_ALPHA, ëèáî 0. Èíà÷å ýòèì êîïèïàñòîì âû
    // ïîðîäèòå íåâíÿòíûé ïàëåíûé êîä è áåçíàäåæíî èñïîðòèòå ñåáå êàðìó. :((
    //
    // Íà äîëëàðû ($) íå îáðàùàéòå âíèìàíèÿ, îíè íóæíû äëÿ îòëàäêè áèáëèîòåêè TXLib. Â âàøåé ïðîãðàììå èõ èñïîëüçîâàòü íå íàäî.
    //
    //                       ____1____   2   ___________3___________     _______________________4________________________
    //                      /         \  |  /                       \   /                                                \.

$   BLENDFUNCTION blend = { AC_SRC_OVER, 0, (BYTE) ROUND (alpha * 255), (BYTE) ((bmap.bmBitsPixel == 32)? AC_SRC_ALPHA : 0) };

    //
    // * Âûçîâ ñòàíäàðòíîé ôóíêöèè Win32::AlphaBlend() *
    //
    // Íèæå - ýòî âûçîâ Win32::AlphaBlend(). Îí òàê óñòðîåí, ÷òî, åñëè âäðóã ÷òî-òî íå ïîëó÷èëîñü (ò.å. Win32::AlphaBlend()
    // âåðíåò 0), òî òîãäà áóäåò âûçâàíà Win32::BitBlt(), êîòîðàÿ ïðîñòî ñêîïèðóåò êàðòèíêó áåç ó÷åòà ïðîçðà÷íîñòè. Ïîãóãëèòå
    // "Windows AlphaBlend function" è ïî÷èòàéòå ïðî åå ïàðàìåòðû.
    //
    // Êàê âèäèòå, îðèãèíàëüíàÿ ôóíêöèÿ èç Win32 ïðèíèìàåò ðàçìåðû íå òîëüêî èñõîäíîé, íî è èòîãîâîé êàðòèíêè, è åñëè îíè íå
    // ñîâïàäàþò, òî êàðòèíêà áóäåò óìåíüøåíà èëè óâåëè÷åíà. TXlib'îâñêàÿ <s>ïàëåíàÿ</s> ôóíêöèÿ txAlphaBlend ïðåäïîëàãàåò, ÷òî
    // ýòè ðàçìåðû âñåãäà ñîâïàäàþò, è ïîýòîìó ïðè ðàáîòå ñ txAlphaBlend() ìàñøòàá áóäåò âñåãäà 1:1. <s>Òàê ñåáå ðåøåíèå, íî</s>
    // ýòî ñäåëàíî äëÿ óïðîùåíèÿ âûçîâà ôóíêöèè txAlphaBlend().

$   if (Win32::AlphaBlend) // Òîëüêî òî, ÷òî ýòè ïàðàìåòðû ïåðåäàþòñÿ îäèíàêîâûìè, íå äàåò âîçìîæíîñòü ìåíÿòü ìàñøòàá êàðòèíêè!   // <<--
        {                  //                           //                                       vvvvv          vvvvvv            // <<--
$       ok &= txGDI (!!(Win32::AlphaBlend (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),          // <<==
                                           sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), blend)), // <<==
                                           destImage);  //                                       ^^^^^          ^^^^^^            // <<--
        }                  //                                                                    |||||          ||||||            // <<--
                           // Ñì. "AlphaBlend function" â Google, èùèòå ñìûñë ïàðàìåòðîâ wSrc è wDest (hSrc è hDest). Äóìàéòå!    // <<--

    else
        {
$       ok &= txGDI (!!(Win32::BitBlt     (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                           sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                           destImage);
$       ok = false;
        }

    //  ýòîé ôóíêöèè ïðîâåðîê è êîììåíòàðèåâ áîëüøå, ÷åì ðàáî÷åãî êîäà, è ýòî êàê áû íàìåêàåò, ÷òî íåòðóäíî ñäåëàòü ñâîþ
    // àíàëîãè÷íóþ ôóíêöèþ áåç îãðàíè÷åíèé ìàñøòàáà îòîáðàæåíèÿ. <s>Åñëè òû äî÷èòàë äî ýòîãî ìåñòà,</s> ïåðåñÿäü ñ èãëû TXLib'à
    // íà ïîâåðõíîñòü GDI Win32, <s>õîòÿ GDI òîæå òàê ñåáå, òàê ÷òî ëó÷øå çàþçàé GDI+, SFML, OpenGL èëè DirectX, áóäåò êðóòî.
    // Õîòÿ ýòî è ñëîæíåå.</s>

    // Íî ïîìíè ïðî ïàëåíûé êîïèïàñò è êàðìó, ñì. âûøå. ß ïðåäóïðåäèë.

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txAlphaBlend (double xDest, double yDest, HDC sourceImage,
                          double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txAlphaBlend (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, alpha);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txUseAlpha (HDC image)
    {
$1  if (_TX_HDC_FAILED (image)) return NULL;

$   HBITMAP bitmap = (HBITMAP) Win32::GetCurrentObject (image, OBJ_BITMAP);
$   if (!bitmap) return NULL;

$   DIBSECTION dib = {};
$   Win32::GetObject (bitmap, sizeof (dib), &dib) asserted;

$   POINT      size = {  dib.dsBm.bmWidth, dib.dsBm.bmHeight };
$   BITMAPINFO info = {{ sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB }};
$   RGBQUAD*   buf  = NULL;

$   bool isDIB = (dib.dsBm.bmPlanes        == 1                    &&
                  dib.dsBm.bmBitsPixel     == sizeof (RGBQUAD) * 8 &&
                  dib.dsBmih.biCompression == DIB_RGB_COLORS       &&
                  dib.dsBm.bmBits);
$   if (!isDIB)
        {
$       buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$       if (!buf) return NULL;

$       Win32::GetDIBits (image, bitmap, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;
        }
    else
        {
$       buf = (RGBQUAD*) dib.dsBm.bmBits;
        }

$   for (int y = 0; y < size.y; y++)
    for (int x = 0; x < size.x; x++)
        {
        RGBQUAD* color = &buf [x + y * size.x];  // Get color at (x, y) within image buffer

        color->rgbRed   = (BYTE) ROUND (color->rgbRed   * color->rgbReserved / 255.0);
        color->rgbGreen = (BYTE) ROUND (color->rgbGreen * color->rgbReserved / 255.0);
        color->rgbBlue  = (BYTE) ROUND (color->rgbBlue  * color->rgbReserved / 255.0);
        }

$   if (!isDIB)
        {
$       Win32::SetDIBitsToDevice (image, 0, 0, size.x, size.y, 0, 0, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;

$       delete[] buf;
        }

$   return image;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSaveImage (const char filename[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (filename)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))       return false;

$   POINT size = txGetExtent (dc);

$   size_t szHdrs = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER),
           szImg  = (size.x * size.y) * sizeof (RGBQUAD);

$   BITMAPFILEHEADER hdr  = { 0x4D42 /* 'MB' */, (DWORD) (szHdrs + szImg), 0, 0, (DWORD) szHdrs };
$   BITMAPINFOHEADER info = { sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB };

$   bool ok = true;

$   RGBQUAD* buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$   ok &= (buf != NULL);

$   if (ok) Win32::GetDIBits (dc, (HBITMAP) Win32::GetCurrentObject (dc, OBJ_BITMAP), 0, size.y,
                              buf, (BITMAPINFO*) &info, DIB_RGB_COLORS) asserted;
$   FILE* f = NULL;
$   if (ok) fopen_s (&f, filename, "wb");
$   ok &= (f != NULL);

$   if (ok) ok &= (fwrite (&hdr,  sizeof (hdr),  1, f) == 1);
$   if (ok) ok &= (fwrite (&info, sizeof (info), 1, f) == 1);
$   if (ok) ok &= (fwrite (buf,   szImg,         1, f) == 1);

$   ok &= (f && fclose (f) == 0);

$   delete[] buf;
$   buf = NULL;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline void txRedrawWindow()
    {
$1  txSleep (0);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txUpdateWindow (int update /*= true*/)
    {
$1  return _txCanvas_SetRefreshLock (update >= 0? !update : -update);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txBegin()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock + 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txEnd()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock - 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

double txSleep (double time)
    {
$1  LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   int lock = _txCanvas_RefreshLock;
$   _txCanvas_RefreshLock = 0;

$   HWND wnd = txWindow();
    if (wnd) {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   Sleep (ROUND ((time >= 0)? time : 0));

$   _txCanvas_RefreshLock = lock;

$   LARGE_INTEGER stop = {};
$   QueryPerformanceCounter (&stop) asserted;

$   return 1000.0 * (double) (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLock (bool wait /*= true*/)
    {
$0  if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);

$   if (wait) {$ return      EnterCriticalSection (&_txCanvas_LockBackBuf), true; }
    else      {$ return !!TryEnterCriticalSection (&_txCanvas_LockBackBuf);       }
    }

//-----------------------------------------------------------------------------------------------------------------

bool txUnlock()
    {
$0  LeaveCriticalSection (&_txCanvas_LockBackBuf);

$   if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T txUnlock (T value)
    {
$1  txUnlock();
$   return value;
    }

//-----------------------------------------------------------------------------------------------------------------

inline POINT txMousePos()
    {
$1  POINT pos = {};
$   GetCursorPos (&pos);

$   if (txWindow())
        {$ ScreenToClient (txWindow(), &pos); }

$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseX()
    {
    return txMousePos() .x;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseY()
    {
    return txMousePos() .y;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txMouseButtons()
    {
$1  return ((GetAsyncKeyState (VK_LBUTTON) & 0x8000) >> 15) |  // MSB to bit 0
           ((GetAsyncKeyState (VK_RBUTTON) & 0x8000) >> 14) |  // MSB to bit 1
           ((GetAsyncKeyState (VK_MBUTTON) & 0x8000) >> 13);   // MSB to bit 2
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetConsoleAttr (unsigned color /*= FOREGROUND_LIGHTGRAY*/)
    {
    unsigned oldAttr = txGetConsoleAttr();

    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), (WORD) color);

    return oldAttr;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txGetConsoleAttr()
    {
    CONSOLE_SCREEN_BUFFER_INFO con = {};
    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);

    return con.wAttributes;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txSetConsoleCursorPos (double x, double y)
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   COORD pos = { (short) ROUND (1.0 * x / fontSz.x + con.srWindow.Left),
                  (short) ROUND (1.0 * y / fontSz.y + con.srWindow.Top ) };

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos) asserted;

$   POINT prev = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return prev;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleCursorPos()
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  pos = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleExtent()
    {
$1  CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  size = { con.srWindow.Right  - con.srWindow.Left + 1,
                    con.srWindow.Bottom - con.srWindow.Top  + 1 };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClearConsole()
    {
$1  HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (out, &con) asserted;

$   COORD start = {con.srWindow.Left, con.srWindow.Top};

$   DWORD len   = (con.srWindow.Right  - con.srWindow.Left + 1) *
                  (con.srWindow.Bottom - con.srWindow.Top  + 1);

$   DWORD written = 0;
$   FillConsoleOutputCharacter (out, 0x20 /*' '*/,    len, start, &written) asserted;
$   FillConsoleOutputAttribute (out, con.wAttributes, len, start, &written) asserted;

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), start) asserted;

$   return written == len;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleFontSize()
    {
$1  Win32::CONSOLE_FONT_INFO font = {0, {8, 16}};

$   _TX_CALL (Win32::GetCurrentConsoleFont, (GetStdHandle (STD_OUTPUT_HANDLE), false, &font));

$   SIZE size = { font.dwFontSize.X, font.dwFontSize.Y };
$   txGDI (Win32::GetTextExtentPoint32 (_txCanvas_BackBuf[1], "W", 1, &size), txDC());

$   POINT sizeFont = { size.cx, size.cy };
$   return sizeFont;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextCursor (bool blink /*= true*/)
    {
$1  bool old = _txConsole_IsBlinking;

$   _txConsole_IsBlinking = blink;

$   return old;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPlaySound (const char filename[] /*= NULL*/, DWORD mode /*= SND_ASYNC*/)
    {
$1  mode |= SND_FILENAME | SND_NODEFAULT | SND_NOWAIT;
$   if (mode & SND_LOOP) mode = (mode & ~SND_SYNC) | SND_ASYNC;

$   if (!filename) mode = SND_PURGE;

$   return !!Win32::PlaySound (filename, NULL, mode);
    }

//-----------------------------------------------------------------------------------------------------------------

int txSpeak (const char* text, ...)
    {
$1  bool verbose = false; (void) verbose;
$   bool async   = false; (void) async;

$   for (; text && *text; text++)
        {
        if      (*text == '\a') {$ async   = true; }
        else if (*text == '\v') {$ verbose = true; }
        else break;
        }

$   char textA [_TX_BUFSIZE] = "You asked to speak empty text. I would rather say that TX Library is cool! Cats rules!";

$   va_list arg; va_start (arg, text);
    if (text && *text) {$ _tx_vsnprintf_s (textA, sizeof (textA) - 1, text, arg); }
$   va_end (arg);

#ifdef TX_USE_SPEAK

    if (text && verbose) {$ printf ("%s", textA); }

$   int time = GetTickCount();

$   static wchar_t textW [_TX_BUFSIZE * sizeof (wchar_t)] = L"";
$   MultiByteToWideChar (_TX_CODEPAGE, 0, textA, -1, textW, sizearr (textW));

$   static ISpVoice* voice = NULL;

$   if (text && !voice)
        {
$       HRESULT res = Win32::CoInitialize (NULL);
        if (res == S_OK) {$ Win32::CoCreateInstance (Win32::CLSID_SpVoice, NULL, CLSCTX_ALL, Win32::IID_ISpVoice, (void**) &voice); }
        }

$   if (text && voice)
        {
$       Win32::_fpreset();
$       voice->Speak (textW, SPF_PERSIST_XML | SPF_PURGEBEFORESPEAK | (async? SPF_ASYNC : 0), NULL);
$       tx_fpreset();
        }

$   if (!text && voice)
        {
$       voice->Release();
$       voice = NULL;

$       Win32::CoUninitialize();
        }

$   return (voice)? GetTickCount() - time : -1;

#else

$   if (text)
        {
$       unsigned oldAttr = txSetConsoleAttr (FOREGROUND_LIGHTRED | BACKGROUND_BLACK);

$       txNotifyIcon (NIIF_ERROR, "txSpeak(): Íå ìîãó ïðîèçíåñòè (íóæåí TX_USE_SPEAK, ñì. TXLib Help)", "\n" "%s", textA);

$       txSetConsoleAttr (oldAttr);
        }

$   return -1;

#endif
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txPlayVideo (int x, int y, int width, int height, const char fileName[],
                      double zoom /*= 0*/, double gain /*= 1*/, HWND wnd /*= txWindow()*/)
    {
$1  if (wnd && wnd == txWindow() && _TX_TXWINDOW_FAILED()) return -1;

$   int time = GetTickCount();

$   static char processUID [64] = "";
    if (!*processUID)
        {
$       FILETIME startTime = {}, null = {};
$       GetProcessTimes (GetCurrentProcess(), &startTime, &null, &null, &null) asserted;
$       _snprintf_s (processUID, sizeof (processUID) - 1, "TXLib[%08X%08X]::txPlayVideo",
                    (unsigned) startTime.dwHighDateTime, (unsigned) startTime.dwLowDateTime) < (int) sizeof (processUID) asserted;
        }

$   if (!fileName)
        {
$       txTaskKill ("vlc.exe", processUID, 0);  // Kill'em all, by command line pattern
$       return 0;
        }

$   static const char* vlcPath = _txPlayVideo_FindVLC();

$   if (!vlcPath || _access (vlcPath, 0) != 0)
        {
$       static int once = false;

$       if (*fileName && !once++)
            {$ txOutputDebugPrintf ("\a" "Íå íàéäåí âèäåîïðîèãðûâàòåëü VideoLAN (vlc.exe). Cêà÷àéòå åãî ñ ñàéòà VideoLAN.org "
                                    "è óñòàíîâèòå. Áåç óñòàíîâêè VideoLAN âèäåî âîñïðîèçâîäèòüñÿ íå áóäåò :(\n\n"
                                    "--\n" "Âñåãäà Âàøà, ôóíêöèÿ " /* êàê áû */ "txPlayVideo()...\n"
                                    "P.S. Ñì. ìîå îïèñàíèå â TXLib Help."); }
$       return INT_MIN;
        }

$   bool async = false;
    if (*fileName == '\a') {$ async = true; fileName++; }

$   RECT rect = {};
    if (wnd) {$ GetClientRect (wnd, &rect); }

    if (!width)  {$ width  = rect.right;  }
    if (!height) {$ height = rect.bottom; }

    // Create a child window to hold the video stream

$   const char* errPos = "ÂÍÅÇÀÏÍÎ";

$   volatile HWND child = NULL;
$   if (wnd && (wnd == txWindow()))
        {
$       const char* wndClass = txRegisterClass ("txPlayVideo", _txPlayVideo_WndProc, 0, NULL_BRUSH, 1);

$       static int number = 1;
$       CREATESTRUCT createData = { NULL, NULL, (HMENU) (size_t) number++, txWindow(), height, width, y, x,
                                    WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, __func__, wndClass };
$       child = txCreateExtraWindow (createData);
$       if (!child)
            {
$           txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                       strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå ìîãó ñîçäàòü îêíî äëÿ âèäåî :("), errPos));
$           return INT_MIN+3;
            }

$       BringWindowToTop (child);

$       wnd = child;
        }

    // Build the command line

    if (!zoom && !wnd) {$ zoom = 1; }

$   char sZoom [64] = "--autoscale";
    if (zoom) {$ _snprintf_s (sZoom, sizeof (sZoom) - 1, "--no-autoscale --zoom=%.10g", zoom) < (int) sizeof (sZoom) asserted; }

$   static char cmd [MAX_PATH*2 + 1024] = "";

$   _snprintf_s (cmd, sizeof (cmd) - 1, "\"%s\" \"%s\" vlc://quit"

                 " %s --gain=%.10g --drawable-hwnd=%" PRIu64 " --video-title=\"%s\" --logfile=%s"

                 " --live-caching=500 --network-caching=500 --quiet-synchro --no-embedded-video --file-logging"

                 " --ignore-config --reset-config --no-one-instance --play-and-exit"
                 " --intf=dummy --dummy-quiet --quiet --no-video-deco --no-video-title-show --no-stats --no-sub-autodetect-file"
                 " --no-disable-screensaver --no-snapshot-preview --no-auto-preparse --no-mouse-events --no-keyboard-events",

                 vlcPath, (*fileName? fileName : "fileName"), sZoom, gain, (uint64_t) wnd, processUID, _txLogName) < (int) sizeof (cmd) asserted;

$   txOutputDebugPrintf ("txPlayVideo (%d, %d, %d, %d, \"%s\", %lg, %lg, %p): [%s]\n\n",
                         x, y, width, height, fileName, zoom, gain, wnd, cmd);
$   if (!*fileName)
        {
        if (child) {$ txDestroyWindow (child); }
$       return (intptr_t) cmd;
        }

$   if (!strstr (fileName, "://") && _access (fileName, 0) != 0)
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå íàéäåí ôàéë \"%s\"", fileName), errPos));

        if (child) {$ txDestroyWindow (child); }
$       return INT_MIN+1;
        }

    // Run VLC, run

$   PROCESS_INFORMATION vlc   = {};
$   STARTUPINFO         start = { sizeof (start) };
$   DWORD               ret   = 0;

$   if (CreateProcess (NULL, cmd, NULL, NULL, true, 0, NULL, NULL, &start, &vlc) &&
        vlc.hProcess && vlc.hThread)
        {
$       if (child)
            {
$           assert (wnd == child);
$           SetWindowLongPtr (wnd, GWLP_USERDATA, (LONG_PTR) vlc.hProcess);
            }

$       if (!async)
            {
$           WaitForSingleObject (vlc.hProcess, INFINITE);
$           GetExitCodeProcess  (vlc.hProcess, &ret) asserted;
            }

$       if (!child)
            {
$           CloseHandle (vlc.hProcess) asserted;
            }

$       CloseHandle (vlc.hThread) asserted;

$       return (async? (intptr_t) wnd : (ret == 0)? time - GetTickCount() : - (int) ret);
        }
    else
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Îøèáêà çàïóñêà VideoLAN (%s)", cmd), errPos));
$       if (child)
            {$ txDestroyWindow (child); }

$       return INT_MIN+4;
        }

    #undef PROCESS_UID_
    }

//-----------------------------------------------------------------------------------------------------------------

inline intptr_t txPlayVideo (const char fileName[], double zoom /*= 0*/, double gain /*= 0*/, HWND wnd /*= txWindow()*/)
    {
$1  return txPlayVideo (0, 0, 0, 0, fileName, zoom, gain, wnd);
    }

//-----------------------------------------------------------------------------------------------------------------

LRESULT CALLBACK _txPlayVideo_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
    const UINT_PTR checkTimer = 1;

    switch (msg)
        {
        case WM_CREATE:
            {
$1          SetTimer  (wnd, checkTimer, 5*_txWindowUpdateInterval, NULL) asserted;
            }
            break;

        case WM_DESTROY:
            {
$1          KillTimer (wnd, checkTimer) asserted;

$           HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

$           if (vlc)
                {
$               Win32::TerminateProcess (vlc, 0);

$               CloseHandle (vlc) asserted;

$               SetWindowLongPtr (wnd, GWLP_USERDATA, 0);
                }
            }
            break;

        case WM_TIMER:
            {
            HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

            if (vlc && WaitForSingleObject (vlc, 0) != WAIT_TIMEOUT)
                {
$1              DestroyWindow (wnd) asserted;
                }
            }
            break;

        default:
            break;
        }

    return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txPlayVideo_FindVLC()
    {
$1  static char vlcPath [MAX_PATH] = "";

$   if (SearchPath (NULL, "vlc.bat", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (SearchPath (NULL, "vlc.exe", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", NULL, vlcPath, sizeof (vlcPath)))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", "InstallDir", vlcPath, sizeof (vlcPath)))
        {
$       strncat_s (vlcPath, sizeof (vlcPath) - 1, "\\vlc.exe", INT_MAX);

        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files"    "\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   return NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// +--<<< Ýòî âðÿä ëè èìååò îòíîøåíèå ê òîìó, ÷òî âû èùåòå :)
// V      Ïîëåçíî ñìîòðåòü íå òîëüêî ââåðõ, íî è âíèç

WNDPROC txSetWindowsHook (WNDPROC wndProc /*= NULL*/)
    {
$1  WNDPROC old = _txAltWndProc; _txAltWndProc = wndProc;
$   return  old;
    }

//-----------------------------------------------------------------------------------------------------------------

//     +--<<< À ýòî, íàêîíåö, èñêîìîå îïðåäåëåíèå ýòîé ôóíêöèè.
//     |      Ñìîòðèòå ïî ñòîðîíàì! Íóæíàÿ âàì ôóíêöèÿ ãäå-òî ðÿäîì.
//     |
//     v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()
    {
    txMessageBox ("Ýòî çàïëàíèðîâàííàÿ îøèáêà. Òàêîå áûâàåò. Âû õîòåëè âûçâàòü:\n\n"

                  "txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()\n\n"

                  "Õîòü âû äîëãî [êîïèðîâàëè]íàáèðàëè ýòî èìÿ, íà ñàìîì äåëå ýòà ôóíêöèÿ íå ðåàëèçîâàíà. "
                  "Åñòü äðóãàÿ ôóíêöèÿ, êîòîðàÿ óáèðàåò àâòî-ïàóçó â êîíöå ïðîãðàììû, íî â õåëïå ïðî íåå íå íàïèñàíî.\n\n"

                  "Íî íå âñå òàê ïëîõî. Îïðåäåëåíèå íóæíîé ôóíêöèè åñòü â èñõîäíûõ òåêñòàõ TXLib.h, îíî ëåæèò ðÿäîì "
                  "ñ îïðåäåëåíèåì òîé ôóíêöèè ñ äëèííûì íàçâàíèåì, êîòîðóþ âû ñåé÷àñ âûçâàëè.\n\n"

                  "Íàæìèòå â ðåäàêòîðå Ctrl+O, íàéäèòå è îòêðîéòå ôàéë TXLib.h (îí ëåæèò â ïàïêå, êóäà âû "
                  "óñòàíîâèëè TXLib), çàòåì íàæìèòå Ctrl+F è èùèòå \"txIDontWant\". Óäà÷è!\n\n",

                  "Íå ïîëó÷èëîñü", MB_ICONSTOP);

    // The truth is out there... (C++files)

    return false;
    }

//-----------------------------------------------------------------------------------------------------------------

// Bingo! Now you are learned to use the Sources, Luke. And may the Source be with you.

inline bool txDisableAutoPause()
    {
    _txExit = true;
    return true;
    }

// P.S. This library contains more undocumented functions. Search them via "Luke" keyword.

//-----------------------------------------------------------------------------------------------------------------

void _txDump (const void* address, const char name[] /*= "_txDump()"*/, bool pause /*= true*/)
    {
$1  assert (!_txIsBadReadPtr (address));

    const unsigned char* p = (const unsigned char*) address;
$   unsigned x = 0;

$   unsigned attr = txGetConsoleAttr();

$   txSetConsoleAttr (FOREGROUND_WHITE);
$   printf ("\n%*.*s ", (int) sizeof (address) * 2, (int) sizeof (address) * 2, ((name)? name : ""));

$   txSetConsoleAttr (FOREGROUND_YELLOW);
$   for (x = 0; x < 16; x++) printf ("%02X ", x);
$   for (x = 0; x < 16; x++) printf ("%X",    x);

$   const char   isCtrl[] = "\a" "\b" "\n" "\r" "\t" "\0";
$   const char   xlatCh[] =  "·"  "·"  "·"  "·"  "·"  "·";
$   const size_t szCtrl   = sizeof (isCtrl) - 1;

$   int oldCP = GetConsoleOutputCP();

$   for (int y = 0; y < 16; y++, p += 16)
        {
        txSetConsoleAttr (FOREGROUND_YELLOW);

        printf ("\n" "%*p ", (int) sizeof (address) * 2, p);

        int color = FOREGROUND_LIGHTGREEN;

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);
            printf ("%02X ", p[x]);
            }

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);

            char c = p[x];
            const char* ctrl = (const char*) memchr (isCtrl, c, szCtrl);
            if (ctrl) c = xlatCh [ctrl - isCtrl];

            if (ctrl) SetConsoleOutputCP (1251);

            printf ("%c", c);

            if (ctrl) SetConsoleOutputCP (oldCP);
            }
        }

$   txSetConsoleAttr (attr);
$   printf ("\n");

$   if (pause)
        {
$       SetConsoleOutputCP (_TX_CODEPAGE);

$       fprintf (stderr, "[Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]                          CodePage = %5d\n", oldCP);
$       (void)_getch();

$       SetConsoleOutputCP (oldCP);
        }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txStackBackTrace (const char file[] /*= "?"*/, int line /*= 0*/, const char func[] /*= "?"*/,
                        bool readSource /*= true*/)
    {
$1  unsigned attr = txGetConsoleAttr();
$   txSetConsoleAttr (FOREGROUND_LIGHTCYAN);

$   fprintf (stderr, "\n" "--------------------------------------------------\n"
                          "Òðàññèðîâêà ñòåêà èç \"%s\" at %s (%d):\n\n"
                          "%s\n\n"
                          "--------------------------------------------------\n\n",
                          func, file, line, _txCaptureStackBackTrace (1, readSource));

$   txSetConsoleAttr (attr);
    }

//-----------------------------------------------------------------------------------------------------------------

char* txDemangle (const char* mangledName, std::nomeow_t)
    {
$1  if (!mangledName) return NULL;

$   char* typeName = NULL;

    #if defined (_GCC_VER)

$   int err = 1;
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err); (void) err;
    if (typeName) {$ return typeName; }

    #endif

$   unsigned short flags = 0;

$   if (mangledName[0] == '.')
        {
$       mangledName++;
$       flags = 0x2800;  // UNDNAME_32_BIT_DECODE | UNDNAME_TYPE_ONLY
        }

$   typeName = _TX_CALL (Win32::__unDName, (NULL, mangledName, 0, malloc, free, flags));
    if (typeName) {$ return typeName; }

$   return _strdup (mangledName);
    }

//-----------------------------------------------------------------------------------------------------------------

std::string txDemangle (const char* mangledName)
    {
$1  char* typeName = txDemangle (mangledName, std::nomeow);
$   std::string name (typeName? typeName : "");
$   free (typeName);

$   return name;
    }

//-----------------------------------------------------------------------------------------------------------------

double txQueryPerformance()
    {
$1  int maxTime    =  500;
$   int maxSamples =  100;
$   POINT size     = {100, 100};

$   HDC dc = _txBuffer_Create (txWindow(), &size, NULL);
$   assert (dc); if (!dc) return -1;

$   DWORD mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), 1);
$   assert (mask);

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   int samples = 0;
$   while (samples++ < maxSamples)
        {
$       LARGE_INTEGER cur = {};
$       QueryPerformanceCounter (&cur) asserted;

$       double t = 1000.0 * (double) (cur.QuadPart - start.QuadPart) / (double) freq.QuadPart;
$       if (t > maxTime) break;

        // Draw test scene

$       for (int y = 0; y < size.y; y++)
        for (int x = 0; x < size.x; x++)     txSetPixel (x, y, TX_BLACK, dc);

$       for (int y = 0; y < size.y; y += 10)
        for (int x = 0; x < size.x; x += 50) txTextOut  (x, y, "*", dc);

$       txEllipse (0, 0, size.x, size.y, dc);
$       txFloodFill (size.x/2, size.y/2, TX_TRANSPARENT, FLOODFILLSURFACE, dc);

$       txBitBlt (dc, size.x/2,        0, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc,        0, size.y/2) asserted;
$       txBitBlt (dc,        0, size.y/2, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, size.x/2,        0) asserted;
        }

$   mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), mask);
$   assert (mask);

$   _txBuffer_Delete (&dc);

$   return 3.0 * samples / sqrt (1.0 * size.x * size.y);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_TX_CPP11)
template <int txFramesToAverage>
#endif

double txGetFPS (int minFrames)
    {
$1  static LARGE_INTEGER time0 = {}; if (!time0.QuadPart) QueryPerformanceCounter (&time0);
$          LARGE_INTEGER time  = {};                      QueryPerformanceCounter (&time);

$   if (time.QuadPart - time0.QuadPart == 0)
        {$ return 0; }

$   LARGE_INTEGER freq = {}; QueryPerformanceFrequency (&freq);

$   double fps = (double) freq.QuadPart / (double) (time.QuadPart - time0.QuadPart);
$   time0 = time;

$   if (txFramesToAverage == 0) return fps;

$   static double average [txFramesToAverage] = {};
$   static unsigned n = 0;

$   average [n++ % txFramesToAverage] = fps;

$   unsigned nn = MIN (n, (unsigned) sizearr (average));

$   static double median  [txFramesToAverage] = {};
$   std::copy (average, average + nn, median);
$   std::nth_element (median, median + nn/2, median + nn);

$   fps = (median [(nn-1) / 2] + median [nn / 2]) / 2.0;

$   return ((int)n >= MIN (minFrames, txFramesToAverage))? fps : 0;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txExtractColor (COLORREF color, COLORREF component)
    {
$1  switch (component)
        {
        case TX_RED:
        case TX_HUE:        $ return (color >>  0) & 0xFF;

        case TX_GREEN:
        case TX_SATURATION: $ return (color >>  8) & 0xFF;

        case TX_BLUE:
        case TX_LIGHTNESS:  $ return (color >> 16) & 0xFF;

        default:            $ return CLR_INVALID;
        }
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txRGB2HSL (COLORREF rgbColor)
    {
$1  int r = (int) txExtractColor (rgbColor, TX_RED),
        g = (int) txExtractColor (rgbColor, TX_GREEN),
        b = (int) txExtractColor (rgbColor, TX_BLUE);

$   double m1 = MAX (MAX (r, g), b) / 255.0,
           m2 = MIN (MIN (r, g), b) / 255.0,
           dm = m1 - m2,
           sm = m1 + m2,

           ir = r / 255.0,
           ig = g / 255.0,
           ib = b / 255.0,

           ih = 0,
           is = 0,
           il = sm / 2;

$   const double prec = 0.001;

$   if (fabs (dm) < prec)
        {
$       is = dm / ((sm <= 1)? sm : (2-sm));

$       double cr = (m1 - ir) / dm,
               cg = (m1 - ig) / dm,
               cb = (m1 - ib) / dm;

$       if (fabs (ir - m1) < prec) ih =     cb - cg;
$       if (fabs (ig - m1) < prec) ih = 2 + cr - cb;
$       if (fabs (ib - m1) < prec) ih = 4 + cg - cr;
        }

$   ih = (ih >= 0)? ih*60 : ih*60 + 360;

$   return RGB (ROUND (ih / 360 * 255), ROUND (is * 255), ROUND (il * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txHSL2RGB (COLORREF hslColor)
    {
$1  struct xRGB
        {
        static double calc (double h, double m1, double m2)
            {
$           if (h < 0)   h += 360;
$           if (h > 360) h -= 360;

$           return (h <  60)? m1 + (m2-m1) *      h  / 60 :
                   (h < 180)? m2 :
                   (h < 240)? m1 + (m2-m1) * (240-h) / 60 :
                              m1;
            }
        };

$   int h = (int) txExtractColor (hslColor, TX_HUE),
        s = (int) txExtractColor (hslColor, TX_SATURATION),
        l = (int) txExtractColor (hslColor, TX_LIGHTNESS);

$   double ih = h / 255.0 * 360.0,
           il = l / 100.0,
           is = s / 100.0,

           m2 = (il <= 0.5)? il * (1 + is) : il + is - il * is,
           m1 = 2 * il - m2,

           ir = s? xRGB::calc (ih + 120, m1, m2) : il,
           ig = s? xRGB::calc (ih,       m1, m2) : il,
           ib = s? xRGB::calc (ih - 120, m1, m2) : il;

$   return RGB (ROUND (ir * 255), ROUND (ig * 255), ROUND (ib * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (std::nomeow_t, double left, double right)
    {
    return left + (right - left) * ((double) rand() / RAND_MAX);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (std::nomeow_t, Tx x, Ta a, Tb b)
    {
    return a <= x && x <= b;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int random (int range)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return rand() % range;
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (double left, double right)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return random (std::nomeow, left, right);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (Tx x, Ta a, Tb b)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return In (std::nomeow, x, a, b);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const POINT& pt, const RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.x, rect.left, rect.right) &&
           In (std::nomeow, pt.y, rect.top,  rect.bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const COORD& pt, const SMALL_RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.X, rect.Left, rect.Right) &&
           In (std::nomeow, pt.Y, rect.Top,  rect.Bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

void tx_fpreset()
    {
$1  txAutoLock _lock;

$   Win32::_fpreset();

$   unsigned new87 = 0x0008001C;  // _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW

    #if !defined (__CYGWIN__)

$   unsigned old87 = 0;
$   if (_controlfp_s (&old87, 0, 0) == 0)
        {$ (void) _controlfp_s (&old87, old87  & ~new87, 0x0008001F); }  // _MCW_EM

    #else

$   Win32::_controlfp (Win32::_controlfp (0, 0) & ~new87, 0x0008001F);    // _MCW_EM

    #endif
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T zero() { T __zero = {}; return __zero; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txPrintf() implementation
//           Ðåàëèçàöèÿ txPrintf()
//=================================================================================================================

#if defined (_TX_CPP11)

template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                                  const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width,                   const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                precision_t prec, const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args);
                                         void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt);

template <typename T>                    void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int*     arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt);

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg, ArgsT... args)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*') {$ stream << std::setw (width); }
    else {$ TX_ERROR ("\"%%*\" required to setwidth (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '*') {$ stream << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%.*\" required to setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*' && fmt[2] == '.' && fmt[3] == '*') {$ stream << std::setw (width) << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%*.*\" required to setwidth (%d) and setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (!fmt[0]) {$}
    else {$ TX_ERROR ("No argument provided for %% in \"%s\" while printing \"%s\"", fmt, format); }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char*, int, const char*& fmt)
    {
$1  assert (&stream);
$   assert (fmt);

$   while (*fmt)
        {
        if (fmt[0] == '%')
            {
            if (fmt[1] == '%') fmt++;
            else break;
            }

        stream << *fmt++;
        }
$   }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg)
    {
$1  assert (&stream);
$   assert (fmt);

$   if (_TX_ARGUMENT_FAILED (&arg)) return;

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   fmt++;

$   char                    oldFill  = stream.fill (' ');
$   std::ios_base::fmtflags oldFlags = stream.flags();

$   for (;;) switch (*fmt)
        {
        case '-': $ stream << std::left;     fmt++; break;
        case '+': $ stream << std::showpos;  fmt++; break;
        case ' ': $ stream.fill (' ');       fmt++; break;
        case '#': $ stream << std::showbase; fmt++; break;
        case '0': $ stream.fill ('0');       fmt++; break;

        default:  $ goto end;
        }
    end:

$   int width = (*fmt != '*')?                  (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0);
$   int prec  = (*fmt == '.')? (*++fmt != '*')? (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0) : 0;

    if (width) {$ stream << std::setw (width);        }
    if (prec)  {$ stream << std::setprecision (prec); }

$   fmt += strspn (fmt, "hljztL");

$   switch (*fmt)
        {
        case '$':
        case '?': $                                              break;

        case 'd':
        case 'i':
        case 'u': $ stream << std::dec;                          break;

        case 'o': $ stream << std::oct;                          break;

        case 'x': $ stream << std::hex;                          break;
        case 'X': $ stream << std::hex        << std::uppercase; break;

        case 'f': $ stream << std::fixed;                        break;
        case 'F': $ stream << std::fixed      << std::uppercase; break;

        case 'e': $ stream << std::scientific;                   break;
        case 'E': $ stream << std::scientific << std::uppercase; break;

        case 'g': $                                              break;
        case 'G': $ stream                    << std::uppercase; break;

        case 'a': $                                              break;
        case 'A': $ stream                    << std::uppercase; break;

        case 'c':
        case 's':
        case 'p': $                                              break;

        default:  $ TX_ERROR ("Invalid format '%.1s' at \"%s\" while printing %s argument %d in \"%s\"", fmt, fmt, txTypename (arg), n, format); break;
        }

$   fmt++;

    if (&arg) {$ stream << arg;      }
    else      {$ stream << "(null)"; }

$   stream.fill  (oldFill);
$   stream.flags (oldFlags);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int* arg)
    {
$1  assert (fmt);

    if (_TX_ARGUMENT_FAILED (arg)) return;

    if (fmt[0] == '%' && fmt[1] == 'n') {$}
    else {$ TX_ERROR ("\"%%n\" required to store print length in int* argument %d in \"%s\"", n, format); }

$   *arg = (int) stream.str().length();

$   fmt += 2;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T> inline const T&    _txPrintfNormalizeArg (const T&           arg) { if (_TX_ARGUMENT_FAILED (&arg)) {;}          return arg;         }
                      inline const char* _txPrintfNormalizeArg (const std::string& arg) { if (_TX_ARGUMENT_FAILED (&arg)) return NULL; return arg.c_str(); }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (std::ostringstream& stream, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&stream)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   const char* fmt = format;
$   _txPrintF (stream, format, 2, fmt, _txPrintfNormalizeArg (args)...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (char buffer[], size_t size, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&buffer)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   if (size > 0) size--;
$   buffer[size] = 0;

$   if (!size) return 0;

$   std::ostringstream stream;
$   stream.rdbuf() -> pubsetbuf (buffer, size);

$   txPrintf (stream, format, args...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline std::string txFormat (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return "";

$   std::ostringstream stream;

$   txPrintf (stream, format, args...);

$   return stream.str();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   return printf ("%s", txFormat (format, args...) .c_str());
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

       int _txPrintfCheck (const char* format, ...) tx_printfy (1);
inline int _txPrintfCheck (const char*,        ...) { return 0; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txDialog methods implementation
//           Ðåàëèçàöèÿ ìåòîäîâ êëàññà txDialog
//
//           See [1] http://msdn.microsoft.com/ru-ru/library/windows/desktop/ms645389%28v=vs.85%29.aspx
//               [2] http://blogs.msdn.microsoft.com/oldnewthing/20050429-00/?p=35743
//               [3] http://blogs.msdn.microsoft.com/oldnewthing/20040623-00/?p=38753
//=================================================================================================================

txDialog::txDialog () :
    layout_ (NULL)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

txDialog::txDialog (const Layout* layout) :
    layout_ (layout)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

const txDialog::Layout* txDialog::setLayout (const Layout* layout)
    {
$1  assert (layout);

$   return ::std::swap (layout_, layout), layout;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (WORD resourceID)
    {
$1  const char* resName = (char*)(uintptr_t) resourceID;

$   if (!FindResource (NULL, resName, RT_DIALOG)) return TX_DEBUG_ERROR ("Íå íàéäåí ðåñóðñ äèàëîãà %d", resourceID), 0;

$   return DialogBoxParam (NULL, resName, NULL, (DLGPROC) DialogProc_, (LPARAM) this);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (const txDialog::Layout* layout /*= NULL*/, size_t bufsize /*= 0*/)
    {
$1  if (!layout)  layout = layout_;
$   if (!layout)  return TX_DEBUG_ERROR ("Íå óñòàíîâëåí äèíàìè÷åñêèé øàáëîí äèàëîãà"), 0;

$   if (!bufsize) bufsize = 1024;

$   DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$   if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà"), 0;

$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };

$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];

$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }

$   tmpl->cdit = (unsigned short) (i-1);

$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);

$   GlobalFree (tmpl);

$   return res;
    }

//-----------------------------------------------------------------------------------------------------------------

int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;

        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;

            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }

$   return FALSE;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;

$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;

$   WORD* pw = (WORD*) globalMem;

$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;

$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }

$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   return pw;
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;

$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;

$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;

$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }

$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }

$   *pw++ = 0;

$   return pw;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================

#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$

//}
//=================================================================================================================

//! @endcond

//=================================================================================================================
//{          Experimental Debugging macros
//! @name    Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//!          âî âðåìÿ åãî âûïîëíåíèÿ.
//!
//!          Ñäåëàé ïðèÿòíûìè òâîè <i>êðóãëûå ñóòêè, MB_ICONEXCLAMATION);
 
    return n;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
intptr_t _tx_snprintf_s (char stream[], intptr_t size, const char format[], ...)
    {
    if (!format) return 0;
 
    va_list arg; va_start (arg, format);
    intptr_t ret = _tx_vsnprintf_s (stream, size, format, arg);
    va_end (arg);
 
    return ret;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
intptr_t _tx_vsnprintf_s (char stream[], intptr_t size, const char format[], va_list arg)
    {
    if (!stream || !format) return 0;
 
    #if defined (_TRUNCATE)
    intptr_t ret = _vsnprintf_s (stream, size, _TRUNCATE, format, arg);
    #else
    intptr_t ret = _vsnprintf   (stream, size,            format, arg);
    #endif
 
    if (ret < 0 && size >= 4)
        {
        const char ellipsis[] = "...";
        size_t     szEllipsis = sizeof (ellipsis) - 1;
 
        strncpy_s (stream + size - szEllipsis, szEllipsis+1, ellipsis, szEllipsis);
        }
 
    return (ret >= 0)? ret : size;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (__CYGWIN__)
 
int _getch()
    {
    termios oldattr = {}; tcgetattr (STDIN_FILENO, &oldattr);
 
    termios newattr = oldattr;
    newattr.c_lflag &= ~(ICANON | ECHO);
    tcsetattr (STDIN_FILENO, TCSANOW, &newattr);
 
    int ch = getchar();
 
    tcsetattr (STDIN_FILENO, TCSANOW, &oldattr);
 
    return ch;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int _putch (int ch)
    {
    termios old = {}; tcgetattr (STDOUT_FILENO, &old);
 
    termios cur = old;
    cur.c_lflag &= ~ICANON;
    cur.c_lflag |=  ECHO;
    tcsetattr (STDOUT_FILENO, TCSANOW, &cur);
 
    putchar (ch);
 
    tcsetattr (STDOUT_FILENO, TCSANOW, &old);
 
    return ch;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int _kbhit()
    {
    termios old = {}; tcgetattr (STDIN_FILENO, &old);
 
    termios cur = old;
    cur.c_lflag &= ~(ICANON | ECHO);
    cur.c_cc[VMIN]  = 1;
    cur.c_cc[VTIME] = 0;
 
    tcsetattr (STDIN_FILENO, TCSAFLUSH, &cur);
 
    fd_set  fd = {}; FD_SET (STDIN_FILENO, &fd);
    timeval tv = {};
 
    int res = select (STDIN_FILENO + 1, &fd, NULL, NULL, &tv) && FD_ISSET (STDIN_FILENO, &fd);
 
    tcsetattr (STDIN_FILENO, TCSAFLUSH, &old);
 
    return res;
    }
 
#endif
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------
//{          Information
//-----------------------------------------------------------------------------------------------------------------
 
const char* txGetModuleFileName (bool fileNameOnly /*= true*/)
    {
    static char name[MAX_PATH] = "";
 
    if (!*name)
        {
        if (!GetModuleFileName (NULL, name, sizeof (name) - 1)) *name = 0;
 
        char* ext = strrchr (name, '.');
        if (ext) _strlwr_s (ext, sizeof (name) - 1 - (ext - name));
        }
 
    assert (*name);
 
    if (fileNameOnly) return name;
 
    static char fullName[MAX_PATH] = "";
    strncpy_s (fullName, sizeof (fullName), name, sizeof (fullName) - 1);
 
    char* title = strrchr (fullName, '\\'); if (!title) title = fullName;
    char* ext   = strrchr (fullName,  '.'); if (!ext)   ext   = fullName + strlen (fullName);
 
    size_t sz = sizeof (fullName) - (ext - fullName);
    strncpy_s (ext, sz-1, " - TXLib", sz);
 
    return title + 1;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
const char* _txAppInfo()
    {
$1  time_t timeT     = time (NULL) - clock()/CLOCKS_PER_SEC;
    char   timeS[32] = "";
    ctime_s (timeS, sizeof (timeS), &timeT);
 
    static char text[_TX_BUFSIZE] = "";
    char cwd [MAX_PATH] = "";
 
    _tx_snprintf_s (text, sizeof (text) - 1,
 
                    "Developed with:\n\n"
                    "The Dumb Artist Library (TX Library)\n"
                    _TX_VERSION "\n" _TX_AUTHOR "\n"
                    "See license on: http://txlib.ru\n\n"
 
                    "TXLib file:" "\t" __FILE__ "\n"
                    "Compiled:"   "\t" __DATE__ " " __TIME__ ", " __TX_COMPILER__ ", %s, %d-bit, " _TX_BUILDMODE "\n"
                    "Started:"    "\t" "%.6s %.4s %.8s\n\n"
 
                    "Run file:"   "\t" "%s\n"
                    "Directory:"  "\t" "%s",
 
    #if   defined (_MSC_VER)
                    "MSVC Runtime",
    #elif defined (__CYGWIN__)
                    "Cygwin Runtime",
    #elif defined (_GCC_VER) && defined (_WIN64)
                    __mingw_get_crt_info(),
    #else
                    "MinGW Runtime " TX_QUOTE (__MINGW32_MAJOR_VERSION) "." TX_QUOTE (__MINGW32_MINOR_VERSION),
    #endif
                    (sizeof (void*) == sizeof (DWORD))? 32 : 64,
 
                    timeS + 4, timeS + 20, timeS + 11,              // These offsets are ANSI standardized
                    txGetModuleFileName(),
                    _getcwd (cwd, sizeof (cwd) - 1));
 
    return text;
    }
 
//}
//-----------------------------------------------------------------------------------------------------------------
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          TXLib API implementation
//           Ðåàëèçàöèÿ TXLib API
//=================================================================================================================
 
inline const char* txVersion()
    {
    return _TX_VERSION;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline unsigned txVersionNumber()
    {
    return _TX_VER;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline HWND txWindow()
    {
$0  return _txCanvas_Window;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline HDC& txDC()
    {
$0  return _txCanvas_BackBuf[0];
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline RGBQUAD* txVideoMemory()
    {
    return _txCanvas_Pixels;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
POINT txGetExtent (HDC dc /*= txDC()*/)
    {
$0  static POINT err = {-1, -1};
 
    if (!dc) {$ POINT screen = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) }; return screen; };
 
    if (_TX_DEFAULT_HDC_FAILED (dc)) {$ return err; }
 
$   BITMAP bmap = {};
$   txGDI (Win32::GetObject (Win32::GetCurrentObject (dc, OBJ_BITMAP), sizeof (bmap), &bmap), dc) asserted;
 
$   POINT  size = { bmap.bmWidth, bmap.bmHeight };
$   return size;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int txGetExtentX (HDC dc /*= txDC()*/)
    {
    return txGetExtent (dc) .x;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int txGetExtentY (HDC dc /*= txDC()*/)
    {
    return txGetExtent (dc) .y;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txDestroyWindow (HWND wnd /*= txWindow()*/)
    {
$1  if (!wnd || !txWindow()) return false;
 
$   if (wnd != txWindow())
        {
$       return !!SendNotifyMessage (txWindow(), _TX_WM_DESTROYWND, 0, (LPARAM) wnd);
        }
 
$   if (SendNotifyMessage (txWindow(), (_txMain? WM_CLOSE : WM_DESTROY), 0, 0) == 0) return false;
 
$   if (_txMain)
        {
$       txNotifyIcon (NIIF_WARNING, NULL, "\n" "Î÷åíü, î÷åíü ïëîõî çàâåðøàòü ïðîãðàììó ÷åðåç txDestroyWindow().\n\n"
                                               "Âîçâðàùàéòåñü ÷åðåç main(), òàì âàì áóäóò ðàäû.\n");
$       Sleep (_TX_TIMEOUT);
        }
 
$   _txWaitFor (!_txCanvas_Window, _TX_TIMEOUT);
 
$   return _txCanvas_Window == NULL;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
HPEN txSetColor (COLORREF color, double thickness /*= 1*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return NULL;
 
$   HPEN pen = Win32::CreatePen ((color == TX_TRANSPARENT? PS_NULL : PS_SOLID), ROUND (thickness), color);
 
$   if (!pen) return (HPEN) NULL;
 
$   if (!_txBuffer_Select (pen, dc))
        {
$       Win32::DeleteObject (pen);
$       return (HPEN) NULL;
        }
 
$   if (txGDI (Win32::SetTextColor (dc, color), dc) == CLR_INVALID)
        {$ return (HPEN) NULL; }
 
$   return pen;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
COLORREF txColor (double red, double green, double blue)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;
 
$   COLORREF color = RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255));
 
$   return txSetColor (color)? color : CLR_INVALID;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
COLORREF txGetColor (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;
 
$   HGDIOBJ obj = txGDI ((Win32::GetCurrentObject (dc, OBJ_PEN)), dc);
$   assert (obj); if (!obj) return CLR_INVALID;
 
$   union { EXTLOGPEN extLogPen; LOGPEN LogPen; } buf = {};
 
$   int size = Win32::GetObject (obj, 0, NULL);
$   Win32::GetObject (obj, sizeof (buf), &buf) asserted;
 
$   return (size == sizeof (LOGPEN))? buf.LogPen.lopnColor : buf.extLogPen.elpColor;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
HBRUSH txSetFillColor (COLORREF color, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return NULL;
 
$   HBRUSH brush = (color == TX_TRANSPARENT)? (HBRUSH) Win32::GetStockObject (HOLLOW_BRUSH) : Win32::CreateSolidBrush (color);
 
$   return (_txBuffer_Select (brush, dc))? brush : (Win32::DeleteObject (brush), (HBRUSH) NULL);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
COLORREF txFillColor (double red, double green, double blue)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;
 
$   COLORREF color = RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255));
 
$   return txSetFillColor (color)? color : CLR_INVALID;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
COLORREF txGetFillColor (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;
 
$   HGDIOBJ obj = txGDI ((Win32::GetCurrentObject (dc, OBJ_BRUSH)), dc);
$   assert (obj); if (!obj) return CLR_INVALID;
 
$   LOGBRUSH buf = {};
$   txGDI ((Win32::GetObject (obj, sizeof (buf), &buf)), dc) asserted;
 
$   return buf.lbColor;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txClear (HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;
 
$   POINT size = txGetExtent (dc);
$   return txGDI (!!(Win32::PatBlt (dc, 0, 0, size.x, size.y, PATCOPY)), dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline bool txSetPixel (double x, double y, COLORREF color, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;
 
$   txGDI ((Win32::SetPixel (dc, ROUND (x), ROUND (y), color)), dc);
 
$   return true;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline bool txPixel (double x, double y, double red, double green, double blue, HDC dc /*= txDC()*/)
    {
$1  if (red   > 1) red   = 1; if (red   < 0) red   = 0;
$   if (green > 1) green = 1; if (green < 0) green = 0;
$   if (blue  > 1) blue  = 1; if (blue  < 0) blue  = 0;
 
$   return txSetPixel (x, y, RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255)), dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline COLORREF txGetPixel (double x, double y, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return CLR_INVALID;
 
$   return txGDI ((Win32::GetPixel (dc, ROUND (x), ROUND (y))), dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txLine (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;
 
$   bool ok  = txGDI ((Win32::MoveToEx (dc, ROUND (x0), ROUND (y0), NULL)), dc);
$        ok &= txGDI ((Win32::LineTo   (dc, ROUND (x1), ROUND (y1)      )), dc);
 
$   return ok;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txRectangle (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;
 
$   return txGDI ((Win32::Rectangle (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1))), dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txPolygon (const POINT points[], int numPoints, HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (points)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))     return false;
 
$   return txGDI (!!(Win32::Polygon (dc, points, numPoints)), dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txEllipse (double x0, double y0, double x1, double y1, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;
 
$   return txGDI ((Win32::Ellipse (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1))), dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txCircle (double x, double y, double r)
    {
$1  return txEllipse (x-r, y-r, x+r, y+r);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txArc (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;
 
$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };
 
$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;
 
$   return txGDI (!!(Win32::Arc (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                     ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                     ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txPie (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;
 
$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };
 
$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;
 
$   return txGDI (!!(Win32::Pie (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                     ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                     ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txChord (double x0, double y0, double x1, double y1, double startAngle, double totalAngle, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;
 
$   POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };
 
$   double start =  startAngle               * txPI/180,
           end   = (startAngle + totalAngle) * txPI/180;
 
$   return txGDI (!!(Win32::Chord (dc, ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
                                       ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
                                       ROUND (center.x + 1E3*cos (end)),   ROUND (center.y - 1E3*sin (end)))), dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txFloodFill (double x, double y,
                  COLORREF color /*= TX_TRANSPARENT*/, DWORD mode /*= FLOODFILLSURFACE*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;
 
$   if (color == TX_TRANSPARENT) color = txGetPixel (x, y, dc);
 
$   return txGDI (!!(Win32::ExtFloodFill (dc, ROUND (x), ROUND (y), color, mode)), dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txTextOut (double x, double y, const char text[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (text)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return false;
 
$   int len = (int) strlen (text);
$   bool ok = txGDI (!!(Win32::TextOut (dc, ROUND (x), ROUND (y), text, len)), dc);
 
$   return ok;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txDrawText (double x0, double y0, double x1, double y1, const char text[],
                 unsigned format /*= DT_CENTER | DT_VCENTER | DT_WORDBREAK | DT_WORD_ELLIPSIS*/,
                 HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (text)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return false;
 
#if !defined (NDEBUG)
 
$   if (x0 > x1)
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïàðàìåòð x0 = %lg áîëüøå, ÷åì x1 = %lg. Òåêñò âûâîäèòüñÿ íå áóäåò.", x0, x1);
        }
 
$   if (y0 > y1)
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïàðàìåòð y0 = %lg áîëüøå, ÷åì y1 = %lg. Òåêñò âûâîäèòüñÿ íå áóäåò.", y0, y1);
        }
 
#endif
 
$   RECT r = { ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1) };
 
$   if (!strchr (text, '\n')) format |= DT_SINGLELINE;
 
$   unsigned prev = txSetTextAlign (TA_LEFT | TA_TOP | TA_NOUPDATECP, dc);
 
$   bool ok = false;
 
$   if (Win32::DrawText)
        {
$       ok = !!txGDI ((Win32::DrawText (dc, text, -1, &r, format)), dc);
$       Win32::GetPixel (dc, 0, 0);
$       ok = true;
        }
    else
        {
$       txTextOut ((x0 + x1) / 2, (y0 + y1) / 2, text);
$       ok = false;
        }
 
$   txSetTextAlign (prev, dc);
 
$   return ok;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
HFONT txSelectFont (const char name[], double sizeY, double sizeX /*= -1*/,
                    int bold /*= FW_DONTCARE*/, bool italic /*= false*/, bool underline /*= false*/,
                    bool strikeout /*= false*/, double angle /*= 0*/,
                    HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (name)) return NULL;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return NULL;
 
$   HFONT font = txFontExist (name)?
                     Win32::CreateFont (ROUND (sizeY), ROUND ((sizeX >= 0)? sizeX : sizeY/3),
                                        ROUND (angle*10), 0, bold, italic, underline, strikeout,
                                        RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                        DEFAULT_QUALITY, DEFAULT_PITCH, name)
                     :
                     (HFONT) Win32::GetStockObject (SYSTEM_FIXED_FONT);
 
$   _txBuffer_Select (font, dc);
 
$   return font;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
SIZE txGetTextExtent (const char text[], HDC dc /*= txDC()*/)
    {
$1  SIZE size = {-1, -1};
 
$   if (_TX_ARGUMENT_FAILED    (text)) return size;
$   if (_TX_DEFAULT_HDC_FAILED (dc))   return size;
 
$   size_t len = strlen (text);
$   txGDI ((Win32::GetTextExtentPoint32 (dc, text, (int) len, &size)), dc) asserted;
 
$   return size;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int txGetTextExtentX (const char text[], HDC dc /*= txDC()*/)
    {
$1  return txGetTextExtent (text, dc) .cx;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int txGetTextExtentY (const char text[], HDC dc /*= txDC()*/)
    {
$1  return txGetTextExtent (text, dc) .cy;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
unsigned txSetTextAlign (unsigned align /*= TA_CENTER | TA_BASELINE*/, HDC dc /*= txDC()*/)
    {
$1  if (_TX_DEFAULT_HDC_FAILED (dc)) return false;
 
$   return txGDI ((Win32::SetTextAlign (dc, align)), dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
LOGFONT* txFontExist (const char name[])
    {
$1  if (_TX_ARGUMENT_FAILED (name)) return NULL;
 
$   static LOGFONT font = {};
$   font.lfCharSet = DEFAULT_CHARSET;
$   strncpy_s (font.lfFaceName, sizeof (font.lfFaceName), name, sizeof (font.lfFaceName) - 1);
 
$   struct tools
        {
        static int CALLBACK enumFonts (const LOGFONT* fnt, const TEXTMETRIC*, DWORD, LPARAM data)
            {
$           if (_TX_ARGUMENT_FAILED (fnt))  return 0;
$           if (_TX_ARGUMENT_FAILED (data)) return 0;
 
            #ifndef __STRICT_ANSI__
$           return _strnicmp (fnt->lfFaceName, ((LOGFONT*)data)->lfFaceName, LF_FACESIZE);
 
            #else
$           return  strncmp  (fnt->lfFaceName, ((LOGFONT*)data)->lfFaceName, LF_FACESIZE);
 
            #endif
            }
        };
 
$   return txGDI ((Win32::EnumFontFamiliesEx (NULL, &font, tools::enumFonts, (LPARAM) &font, 0)), NULL) == 0? &font : NULL;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txSelectObject (HGDIOBJ obj, HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (obj)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))  return false;
 
$   return _txBuffer_Select (obj, dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
HDC txCreateCompatibleDC (double sizeX, double sizeY, HBITMAP bitmap /*= NULL*/)
    {
$1  POINT size = { ROUND (sizeX), ROUND (sizeY) };
 
$   HDC dc = _txBuffer_Create (NULL, &size, bitmap);
$   assert (dc); if (!dc) return NULL;
 
$   txSetDefaults (dc);
 
$   if (!_txCanvas_UserDCs) return dc;
 
$   txAutoLock _lock;
$   _txCanvas_UserDCs->push_back (dc);
 
$   if (_txCanvas_UserDCs->size() >= _TX_BUFSIZE)
        {$ txNotifyIcon (NIIF_WARNING, NULL, "Âû çàãðóçèëè óæå %d HDC, ñèñòåìå ìîæåò ñòàòü ïëîõî.", (int) _txCanvas_UserDCs->size()); }
 
$   return dc;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
HDC txCreateDIBSection (double sizeX, double sizeY, RGBQUAD** pixels /*= NULL*/)
    {
$1  RGBQUAD* buf = NULL;
$   if (!pixels) pixels = &buf;
 
$   BITMAPINFO info = {{ sizeof (info), ROUND (sizeX), ROUND (sizeY), 1, WORD (sizeof (RGBQUAD) * 8), BI_RGB }};
 
$   HDC dc = txCreateCompatibleDC (0, 0, Win32::CreateDIBSection (NULL, &info, DIB_RGB_COLORS, (void**) pixels, NULL, 0));
 
$   RGBQUAD black = { 0, 0, 0, 255 };
$   for (int i = 0; i < sizeX * sizeY; i++) (*pixels)[i] = black;
 
$   return dc;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
HDC txCreateDIBSection (double sizeX, double sizeY, COLORREF** pixels)
    {
$1  return txCreateDIBSection (sizeX, sizeY, (RGBQUAD**) pixels);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
HDC txLoadImage (const char filename[], unsigned imageFlags /*= IMAGE_BITMAP*/, unsigned loadFlags /*= LR_LOADFROMFILE*/)
    {
$1  if (_TX_ARGUMENT_FAILED (filename && *filename)) return NULL;
 
$   HBITMAP image = (HBITMAP) Win32::LoadImage ((loadFlags & LR_LOADFROMFILE)? NULL : GetModuleHandle (NULL),
                                                 filename, imageFlags, 0, 0, loadFlags);
$   if (!image) return NULL;
 
$   HDC dc = txCreateCompatibleDC (0, 0, image);
 
$   if (!(loadFlags & LR_LOADFROMFILE)) return dc;
 
$   static std::map <std::string, unsigned> loadTimes;
$   std::string file = filename;
$   unsigned time    = GetTickCount();
 
$   if ((long) (time - loadTimes [file]) < _TX_TIMEOUT)
        {$ txNotifyIcon (NIIF_WARNING, NULL, "Âû çàãðóæàåòå \"%s\" ñëèøêîì ÷àñòî, ïðîãðàììà áóäåò òîðìîçèòü.", filename); }
 
$   loadTimes [file] = time;
 
$   return dc;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txDeleteDC (HDC* pdc)
    {
$1  if (_TX_ARGUMENT_FAILED (pdc)) return false;
 
$   HDC  dc = *pdc;
$   bool ok = _txBuffer_Delete (pdc);
$   if (!ok) return false;
 
$   if (!_txCanvas_UserDCs) return ok;
 
$   txAutoLock _lock;
$   std::vector <HDC> ::iterator it = std::find (_txCanvas_UserDCs->begin(), _txCanvas_UserDCs->end(), dc);
$   if  (it != _txCanvas_UserDCs->end()) { std::swap (*it, _txCanvas_UserDCs->back()); _txCanvas_UserDCs->pop_back(); }
 
$   return ok;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txDeleteDC (HDC dc)
    {
$1  return txDeleteDC (&dc);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txBitBlt (HDC destImage,   double xDest, double yDest, double width, double height,
               HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, unsigned operation /*= SRCCOPY*/)
    {
$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;
 
$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;
 
$   return txGDI (!!(Win32::BitBlt (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                    sourceImage, ROUND (xSource), ROUND (ySource), operation)), destImage);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline bool txBitBlt (double xDest, double yDest, HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;
 
$   return txBitBlt (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txTransparentBlt (HDC destImage,   double xDest, double yDest, double width, double height,
                       HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, COLORREF transColor /*= TX_BLACK*/)
    {
$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;
 
$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;
 
#if !defined (NDEBUG)
 
$   if (!(0 <= xSource && xSource + width  <= size.x &&
          0 <= ySource && ySource + height <= size.y))
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïðÿìîóãîëüíèê êîïèðóåìîé îáëàñòè {%lg, %lg, %lg, %lg} íå ïîëíîñòüþ ëåæèò âíóòðè èçîáðàæåíèÿ-èñòî÷íèêà {%d, %d, %d, %d}, "
                  "ôóíêöèÿ txTransparentBlt() ðàáîòàòü íå áóäåò.", xSource, ySource, xSource + width, ySource + height, 0, 0, (int) size.x, (int) size.y);
        }
 
#endif
 
$   bool ok = (Win32::TransparentBlt != NULL);
 
$   if (ok)
        {
$       ok &= txGDI (!!(Win32::TransparentBlt (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                               sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), transColor)),
                                               destImage);
        }
    else
        {
$       ok &= txGDI (!!(Win32::BitBlt         (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                               sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                               destImage);
        }
 
    return ok;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline bool txTransparentBlt (double xDest, double yDest, HDC sourceImage,
                              COLORREF transColor /*= TX_BLACK*/, double xSource /*= 0*/, double ySource /*= 0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;
 
$   return txTransparentBlt (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, transColor);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txAlphaBlend (HDC destImage,   double xDest, double yDest, double width, double height,
                   HDC sourceImage, double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
    // Ýòî ïðîâåðêè òîãî, ïðàâèëüíûå ëè HDC âû ïåðåäàëè â ôóíêöèþ.
    // Íå áîéòåñü äîëëàðîâ - <s>ýòî íå çàïðåùåííàÿ âàëþòà</s> ýòî ìàêðîñû äëÿ îòëàäêè TXLib'à.
 
$1  if (_TX_HDC_FAILED (destImage))   return false;
$   if (_TX_HDC_FAILED (sourceImage)) return false;
 
    // Ýòî àâòîìàòè÷åñêîå îïðåäåëåíèå ðàçìåðîâ êàðòèíêè (òî÷íåå, HDC èñòî÷íèêà - source) ñ ïîìîùüþ txGetExtent().
 
$   POINT size = txGetExtent (sourceImage);
$   if (!width)  width  = size.x;
$   if (!height) height = size.y;
 
    // Ýòî ïðîâåðêà òîãî, ÷òî êàðòèíêà (èëè åå ÷àñòü) ïðàâèëüíî ïîïàäàåò â îêíî (òî÷íåå, HDC ïðèåìíèêà - destination, dest).
    // Åñëè îíà "âûëåçàåò" èç îêíà â ëþáóþ ñòîðîíó, òî Win32::AlphaBlend íå áóäåò ðàáîòàòü. Ýòà ïðîâåðêà ïðîèñõîäèò òîëüêî
    // â ðåæèìå îòëàäêè (êîãäà íå çàäàí ìàêðîñ NDEBUG - No Debugging, áåç îòëàäêè).
 
#if !defined (NDEBUG)
 
$   if (!(0 <= xSource && xSource + width  <= size.x &&
          0 <= ySource && ySource + height <= size.y))
        {
$       SetLastError (ERROR_INVALID_DATA);
$       TX_ERROR ("Ïðÿìîóãîëüíèê êîïèðóåìîé îáëàñòè {%lg, %lg, %lg, %lg} íå ïîëíîñòüþ ëåæèò âíóòðè èçîáðàæåíèÿ-èñòî÷íèêà {%d, %d, %d, %d}, "
                  "ôóíêöèÿ txAlphaBlend() ðàáîòàòü íå áóäåò.", xSource, ySource, xSource + width, ySource + height, 0, 0, (int) size.x, (int) size.y);
        }
 
#endif
 
    // Ýòî íà ñëó÷àé, åñëè ïàðàìåòð alpha âûëåçàåò çà äèàïàçîí [0..1].
 
$   if (alpha < 0) alpha = 0;
$   if (alpha > 1) alpha = 1;
 
    // Îá ýòîì ñì. íèæå.
 
$   BITMAP bmap = { 0, 0, 0, 0, 0, 24 };
$   bool ok = !!Win32::GetObject (txGDI ((Win32::GetCurrentObject (sourceImage, OBJ_BITMAP)), sourceImage), sizeof (bmap), &bmap);
 
    //
    // * Ñòðóêòóðà BLENDFUNCTION *
    //
    // Ýòà ñòðóêòóðà îïðåäåëÿåò, êàê öâåòà ïèêñåëåé îêíà (òî÷íåå, source DC) è êàðòèíêè ñìåøèâàþòñÿ ïðè ðèñîâàíèè ñ ó÷åòîì
    // ïðîçðà÷íîñòè.
    //
    // Ïàðàìåòðû ñìåøèâàíèÿ ïîìåùàþòñÿ â ãðóïïó èç ïåðåìåííûõ - òàê íàçûâàåìóþ ñòðóêòóðó. Ïåðåìåííûå, âõîäÿùèå â ñòðóêòóðó,
    // íàçûâàþòñÿ êîìïîíåíòàìè ñòðóêòóðû.
    //
    //  ýòîé ñòðóêòóðå áîëåå âñåõ âàæåí åå òðåòèé êîìïîíåíò (ñì. íèæå), çàäàþùèé ïðîçðà÷íîñòü êàðòèíêè.
    // Åñëè îí ðàâåí íóëþ - òî êàðòèíêà áóäåò ñ÷èòàòüñÿ ïîëíîñòüþ ïðîçðà÷íîé è âûçîâ Win32::AlphaBlend íè÷åãî íå íàðèñóåò.
    // Åñëè îí ðàâåí 255  - òî êàðòèíêà ñêîïèðóåòñÿ â îêíî ïîëíîñòüþ, áåç ýôôåêòà ïðîçðà÷íîñòè.
    //
    // Ñ ïîìîùüþ ÷åòâåðòîãî êîìïîíåíòà ñòðóêòóðû ñèñòåìà ðèñîâàíèÿ Windows (Win32 GDI) óçíàåò, íàäî ëè ó÷èòûâàòü àëüôà-êàíàë    // â êîïèðóåìîé êàðòèíêå èëè åãî íàäî èãíîðèðîâàòü. Åñëè â êàðòèíêå ôàêòè÷åñêè åñòü ïðàâèëüíî ïîñòðîåííûé àëüôà-êàíàë
    // (ñì. îïèñàíèå ôóíêöèè txAlphaBlend â ñèñòåìå ïîìîùè TXLib), òî ÷åòâåðòûé êîìïîíåíò ñòðóêòóðû íàäî çàäàòü êàê êîíñòàíòó
    // AC_SRC_ALPHA.
    //
    // Åñëè â êàðòèíêå àëüôà-êàíàëà ôàêòè÷åñêè íåò, òî ÷åòâåðòûé ïàðàìåòð íàäî óñòàíîâèòü â 0.
    //
    //  êîäå íèæå ÷åòâåðòûé ïàðàìåòð îïðåäåëÿåòñÿ àâòîìàòè÷åñêè èç âûçîâà Win32::GetObject(), äëÿ óíèâåðñàëüíîñòè ïðèìåíåíèÿ
    // ôóíêöèè txAlphaBlend().
    //
    // Ïîæàëóéñòà, íå íàäî áåçäóìíî êîïèðîâàòü ñåáå â ïðîãðàììó ýòîò êîä. Îñìûñëèòå åãî, è ðåøèòå, áóäåòå ëè âû èñïîëüçîâàòü
    // àëüôà-êàíàë èëè íåò, è óñòàíîâèòå ÷åòâåðòûé ïàðàìåòð ñòðóêòóðû ëèáî AC_SRC_ALPHA, ëèáî 0. Èíà÷å ýòèì êîïèïàñòîì âû
    // ïîðîäèòå íåâíÿòíûé ïàëåíûé êîä è áåçíàäåæíî èñïîðòèòå ñåáå êàðìó. :((
    //
    // Íà äîëëàðû ($) íå îáðàùàéòå âíèìàíèÿ, îíè íóæíû äëÿ îòëàäêè áèáëèîòåêè TXLib. Â âàøåé ïðîãðàììå èõ èñïîëüçîâàòü íå íàäî.
    //
    //                       ____1____   2   ___________3___________     _______________________4________________________
    //                      /         \  |  /                       \   /                                                \.

$   BLENDFUNCTION blend = { AC_SRC_OVER, 0, (BYTE) ROUND (alpha * 255), (BYTE) ((bmap.bmBitsPixel == 32)? AC_SRC_ALPHA : 0) };

    //
    // * Âûçîâ ñòàíäàðòíîé ôóíêöèè Win32::AlphaBlend() *
    //
    // Íèæå - ýòî âûçîâ Win32::AlphaBlend(). Îí òàê óñòðîåí, ÷òî, åñëè âäðóã ÷òî-òî íå ïîëó÷èëîñü (ò.å. Win32::AlphaBlend()
    // âåðíåò 0), òî òîãäà áóäåò âûçâàíà Win32::BitBlt(), êîòîðàÿ ïðîñòî ñêîïèðóåò êàðòèíêó áåç ó÷åòà ïðîçðà÷íîñòè. Ïîãóãëèòå
    // "Windows AlphaBlend function" è ïî÷èòàéòå ïðî åå ïàðàìåòðû.
    //
    // Êàê âèäèòå, îðèãèíàëüíàÿ ôóíêöèÿ èç Win32 ïðèíèìàåò ðàçìåðû íå òîëüêî èñõîäíîé, íî è èòîãîâîé êàðòèíêè, è åñëè îíè íå
    // ñîâïàäàþò, òî êàðòèíêà áóäåò óìåíüøåíà èëè óâåëè÷åíà. TXlib'îâñêàÿ <s>ïàëåíàÿ</s> ôóíêöèÿ txAlphaBlend ïðåäïîëàãàåò, ÷òî
    // ýòè ðàçìåðû âñåãäà ñîâïàäàþò, è ïîýòîìó ïðè ðàáîòå ñ txAlphaBlend() ìàñøòàá áóäåò âñåãäà 1:1. <s>Òàê ñåáå ðåøåíèå, íî</s>
    // ýòî ñäåëàíî äëÿ óïðîùåíèÿ âûçîâà ôóíêöèè txAlphaBlend().

$   if (Win32::AlphaBlend) // Òîëüêî òî, ÷òî ýòè ïàðàìåòðû ïåðåäàþòñÿ îäèíàêîâûìè, íå äàåò âîçìîæíîñòü ìåíÿòü ìàñøòàá êàðòèíêè!   // <<--
        {                  //                           //                                       vvvvv          vvvvvv            // <<--
$       ok &= txGDI (!!(Win32::AlphaBlend (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),          // <<==
                                           sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), blend)), // <<==
                                           destImage);  //                                       ^^^^^          ^^^^^^            // <<--
        }                  //                                                                    |||||          ||||||            // <<--
                           // Ñì. "AlphaBlend function" â Google, èùèòå ñìûñë ïàðàìåòðîâ wSrc è wDest (hSrc è hDest). Äóìàéòå!    // <<--

    else
        {
$       ok &= txGDI (!!(Win32::BitBlt     (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                           sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                           destImage);
$       ok = false;
        }

    //  ýòîé ôóíêöèè ïðîâåðîê è êîììåíòàðèåâ áîëüøå, ÷åì ðàáî÷åãî êîäà, è ýòî êàê áû íàìåêàåò, ÷òî íåòðóäíî ñäåëàòü ñâîþ
    // àíàëîãè÷íóþ ôóíêöèþ áåç îãðàíè÷åíèé ìàñøòàáà îòîáðàæåíèÿ. <s>Åñëè òû äî÷èòàë äî ýòîãî ìåñòà,</s> ïåðåñÿäü ñ èãëû TXLib'à
    // íà ïîâåðõíîñòü GDI Win32, <s>õîòÿ GDI òîæå òàê ñåáå, òàê ÷òî ëó÷øå çàþçàé GDI+, SFML, OpenGL èëè DirectX, áóäåò êðóòî.
    // Õîòÿ ýòî è ñëîæíåå.</s>

    // Íî ïîìíè ïðî ïàëåíûé êîïèïàñò è êàðìó, ñì. âûøå. ß ïðåäóïðåäèë.

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txAlphaBlend (double xDest, double yDest, HDC sourceImage,
                          double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txAlphaBlend (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, alpha);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txUseAlpha (HDC image)
    {
$1  if (_TX_HDC_FAILED (image)) return NULL;

$   HBITMAP bitmap = (HBITMAP) Win32::GetCurrentObject (image, OBJ_BITMAP);
$   if (!bitmap) return NULL;

$   DIBSECTION dib = {};
$   Win32::GetObject (bitmap, sizeof (dib), &dib) asserted;

$   POINT      size = {  dib.dsBm.bmWidth, dib.dsBm.bmHeight };
$   BITMAPINFO info = {{ sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB }};
$   RGBQUAD*   buf  = NULL;

$   bool isDIB = (dib.dsBm.bmPlanes        == 1                    &&
                  dib.dsBm.bmBitsPixel     == sizeof (RGBQUAD) * 8 &&
                  dib.dsBmih.biCompression == DIB_RGB_COLORS       &&
                  dib.dsBm.bmBits);
$   if (!isDIB)
        {
$       buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$       if (!buf) return NULL;

$       Win32::GetDIBits (image, bitmap, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;
        }
    else
        {
$       buf = (RGBQUAD*) dib.dsBm.bmBits;
        }

$   for (int y = 0; y < size.y; y++)
    for (int x = 0; x < size.x; x++)
        {
        RGBQUAD* color = &buf [x + y * size.x];  // Get color at (x, y) within image buffer

        color->rgbRed   = (BYTE) ROUND (color->rgbRed   * color->rgbReserved / 255.0);
        color->rgbGreen = (BYTE) ROUND (color->rgbGreen * color->rgbReserved / 255.0);
        color->rgbBlue  = (BYTE) ROUND (color->rgbBlue  * color->rgbReserved / 255.0);
        }

$   if (!isDIB)
        {
$       Win32::SetDIBitsToDevice (image, 0, 0, size.x, size.y, 0, 0, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;

$       delete[] buf;
        }

$   return image;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSaveImage (const char filename[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (filename)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))       return false;

$   POINT size = txGetExtent (dc);

$   size_t szHdrs = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER),
           szImg  = (size.x * size.y) * sizeof (RGBQUAD);

$   BITMAPFILEHEADER hdr  = { 0x4D42 /* 'MB' */, (DWORD) (szHdrs + szImg), 0, 0, (DWORD) szHdrs };
$   BITMAPINFOHEADER info = { sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB };

$   bool ok = true;

$   RGBQUAD* buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$   ok &= (buf != NULL);

$   if (ok) Win32::GetDIBits (dc, (HBITMAP) Win32::GetCurrentObject (dc, OBJ_BITMAP), 0, size.y,
                              buf, (BITMAPINFO*) &info, DIB_RGB_COLORS) asserted;
$   FILE* f = NULL;
$   if (ok) fopen_s (&f, filename, "wb");
$   ok &= (f != NULL);

$   if (ok) ok &= (fwrite (&hdr,  sizeof (hdr),  1, f) == 1);
$   if (ok) ok &= (fwrite (&info, sizeof (info), 1, f) == 1);
$   if (ok) ok &= (fwrite (buf,   szImg,         1, f) == 1);

$   ok &= (f && fclose (f) == 0);

$   delete[] buf;
$   buf = NULL;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline void txRedrawWindow()
    {
$1  txSleep (0);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txUpdateWindow (int update /*= true*/)
    {
$1  return _txCanvas_SetRefreshLock (update >= 0? !update : -update);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txBegin()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock + 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txEnd()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock - 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

double txSleep (double time)
    {
$1  LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   int lock = _txCanvas_RefreshLock;
$   _txCanvas_RefreshLock = 0;

$   HWND wnd = txWindow();
    if (wnd) {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   Sleep (ROUND ((time >= 0)? time : 0));

$   _txCanvas_RefreshLock = lock;

$   LARGE_INTEGER stop = {};
$   QueryPerformanceCounter (&stop) asserted;

$   return 1000.0 * (double) (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLock (bool wait /*= true*/)
    {
$0  if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);

$   if (wait) {$ return      EnterCriticalSection (&_txCanvas_LockBackBuf), true; }
    else      {$ return !!TryEnterCriticalSection (&_txCanvas_LockBackBuf);       }
    }

//-----------------------------------------------------------------------------------------------------------------

bool txUnlock()
    {
$0  LeaveCriticalSection (&_txCanvas_LockBackBuf);

$   if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T txUnlock (T value)
    {
$1  txUnlock();
$   return value;
    }

//-----------------------------------------------------------------------------------------------------------------

inline POINT txMousePos()
    {
$1  POINT pos = {};
$   GetCursorPos (&pos);

$   if (txWindow())
        {$ ScreenToClient (txWindow(), &pos); }

$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseX()
    {
    return txMousePos() .x;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseY()
    {
    return txMousePos() .y;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txMouseButtons()
    {
$1  return ((GetAsyncKeyState (VK_LBUTTON) & 0x8000) >> 15) |  // MSB to bit 0
           ((GetAsyncKeyState (VK_RBUTTON) & 0x8000) >> 14) |  // MSB to bit 1
           ((GetAsyncKeyState (VK_MBUTTON) & 0x8000) >> 13);   // MSB to bit 2
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetConsoleAttr (unsigned color /*= FOREGROUND_LIGHTGRAY*/)
    {
    unsigned oldAttr = txGetConsoleAttr();

    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), (WORD) color);

    return oldAttr;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txGetConsoleAttr()
    {
    CONSOLE_SCREEN_BUFFER_INFO con = {};
    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);

    return con.wAttributes;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txSetConsoleCursorPos (double x, double y)
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   COORD pos = { (short) ROUND (1.0 * x / fontSz.x + con.srWindow.Left),
                  (short) ROUND (1.0 * y / fontSz.y + con.srWindow.Top ) };

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos) asserted;

$   POINT prev = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return prev;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleCursorPos()
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  pos = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleExtent()
    {
$1  CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  size = { con.srWindow.Right  - con.srWindow.Left + 1,
                    con.srWindow.Bottom - con.srWindow.Top  + 1 };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClearConsole()
    {
$1  HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (out, &con) asserted;

$   COORD start = {con.srWindow.Left, con.srWindow.Top};

$   DWORD len   = (con.srWindow.Right  - con.srWindow.Left + 1) *
                  (con.srWindow.Bottom - con.srWindow.Top  + 1);

$   DWORD written = 0;
$   FillConsoleOutputCharacter (out, 0x20 /*' '*/,    len, start, &written) asserted;
$   FillConsoleOutputAttribute (out, con.wAttributes, len, start, &written) asserted;

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), start) asserted;

$   return written == len;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleFontSize()
    {
$1  Win32::CONSOLE_FONT_INFO font = {0, {8, 16}};

$   _TX_CALL (Win32::GetCurrentConsoleFont, (GetStdHandle (STD_OUTPUT_HANDLE), false, &font));

$   SIZE size = { font.dwFontSize.X, font.dwFontSize.Y };
$   txGDI (Win32::GetTextExtentPoint32 (_txCanvas_BackBuf[1], "W", 1, &size), txDC());

$   POINT sizeFont = { size.cx, size.cy };
$   return sizeFont;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextCursor (bool blink /*= true*/)
    {
$1  bool old = _txConsole_IsBlinking;

$   _txConsole_IsBlinking = blink;

$   return old;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPlaySound (const char filename[] /*= NULL*/, DWORD mode /*= SND_ASYNC*/)
    {
$1  mode |= SND_FILENAME | SND_NODEFAULT | SND_NOWAIT;
$   if (mode & SND_LOOP) mode = (mode & ~SND_SYNC) | SND_ASYNC;

$   if (!filename) mode = SND_PURGE;

$   return !!Win32::PlaySound (filename, NULL, mode);
    }

//-----------------------------------------------------------------------------------------------------------------

int txSpeak (const char* text, ...)
    {
$1  bool verbose = false; (void) verbose;
$   bool async   = false; (void) async;

$   for (; text && *text; text++)
        {
        if      (*text == '\a') {$ async   = true; }
        else if (*text == '\v') {$ verbose = true; }
        else break;
        }

$   char textA [_TX_BUFSIZE] = "You asked to speak empty text. I would rather say that TX Library is cool! Cats rules!";

$   va_list arg; va_start (arg, text);
    if (text && *text) {$ _tx_vsnprintf_s (textA, sizeof (textA) - 1, text, arg); }
$   va_end (arg);

#ifdef TX_USE_SPEAK

    if (text && verbose) {$ printf ("%s", textA); }

$   int time = GetTickCount();

$   static wchar_t textW [_TX_BUFSIZE * sizeof (wchar_t)] = L"";
$   MultiByteToWideChar (_TX_CODEPAGE, 0, textA, -1, textW, sizearr (textW));

$   static ISpVoice* voice = NULL;

$   if (text && !voice)
        {
$       HRESULT res = Win32::CoInitialize (NULL);
        if (res == S_OK) {$ Win32::CoCreateInstance (Win32::CLSID_SpVoice, NULL, CLSCTX_ALL, Win32::IID_ISpVoice, (void**) &voice); }
        }

$   if (text && voice)
        {
$       Win32::_fpreset();
$       voice->Speak (textW, SPF_PERSIST_XML | SPF_PURGEBEFORESPEAK | (async? SPF_ASYNC : 0), NULL);
$       tx_fpreset();
        }

$   if (!text && voice)
        {
$       voice->Release();
$       voice = NULL;

$       Win32::CoUninitialize();
        }

$   return (voice)? GetTickCount() - time : -1;

#else

$   if (text)
        {
$       unsigned oldAttr = txSetConsoleAttr (FOREGROUND_LIGHTRED | BACKGROUND_BLACK);

$       txNotifyIcon (NIIF_ERROR, "txSpeak(): Íå ìîãó ïðîèçíåñòè (íóæåí TX_USE_SPEAK, ñì. TXLib Help)", "\n" "%s", textA);

$       txSetConsoleAttr (oldAttr);
        }

$   return -1;

#endif
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txPlayVideo (int x, int y, int width, int height, const char fileName[],
                      double zoom /*= 0*/, double gain /*= 1*/, HWND wnd /*= txWindow()*/)
    {
$1  if (wnd && wnd == txWindow() && _TX_TXWINDOW_FAILED()) return -1;

$   int time = GetTickCount();

$   static char processUID [64] = "";
    if (!*processUID)
        {
$       FILETIME startTime = {}, null = {};
$       GetProcessTimes (GetCurrentProcess(), &startTime, &null, &null, &null) asserted;
$       _snprintf_s (processUID, sizeof (processUID) - 1, "TXLib[%08X%08X]::txPlayVideo",
                    (unsigned) startTime.dwHighDateTime, (unsigned) startTime.dwLowDateTime) < (int) sizeof (processUID) asserted;
        }

$   if (!fileName)
        {
$       txTaskKill ("vlc.exe", processUID, 0);  // Kill'em all, by command line pattern
$       return 0;
        }

$   static const char* vlcPath = _txPlayVideo_FindVLC();

$   if (!vlcPath || _access (vlcPath, 0) != 0)
        {
$       static int once = false;

$       if (*fileName && !once++)
            {$ txOutputDebugPrintf ("\a" "Íå íàéäåí âèäåîïðîèãðûâàòåëü VideoLAN (vlc.exe). Cêà÷àéòå åãî ñ ñàéòà VideoLAN.org "
                                    "è óñòàíîâèòå. Áåç óñòàíîâêè VideoLAN âèäåî âîñïðîèçâîäèòüñÿ íå áóäåò :(\n\n"
                                    "--\n" "Âñåãäà Âàøà, ôóíêöèÿ " /* êàê áû */ "txPlayVideo()...\n"
                                    "P.S. Ñì. ìîå îïèñàíèå â TXLib Help."); }
$       return INT_MIN;
        }

$   bool async = false;
    if (*fileName == '\a') {$ async = true; fileName++; }

$   RECT rect = {};
    if (wnd) {$ GetClientRect (wnd, &rect); }

    if (!width)  {$ width  = rect.right;  }
    if (!height) {$ height = rect.bottom; }

    // Create a child window to hold the video stream

$   const char* errPos = "ÂÍÅÇÀÏÍÎ";

$   volatile HWND child = NULL;
$   if (wnd && (wnd == txWindow()))
        {
$       const char* wndClass = txRegisterClass ("txPlayVideo", _txPlayVideo_WndProc, 0, NULL_BRUSH, 1);

$       static int number = 1;
$       CREATESTRUCT createData = { NULL, NULL, (HMENU) (size_t) number++, txWindow(), height, width, y, x,
                                    WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, __func__, wndClass };
$       child = txCreateExtraWindow (createData);
$       if (!child)
            {
$           txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                       strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå ìîãó ñîçäàòü îêíî äëÿ âèäåî :("), errPos));
$           return INT_MIN+3;
            }

$       BringWindowToTop (child);

$       wnd = child;
        }

    // Build the command line

    if (!zoom && !wnd) {$ zoom = 1; }

$   char sZoom [64] = "--autoscale";
    if (zoom) {$ _snprintf_s (sZoom, sizeof (sZoom) - 1, "--no-autoscale --zoom=%.10g", zoom) < (int) sizeof (sZoom) asserted; }

$   static char cmd [MAX_PATH*2 + 1024] = "";

$   _snprintf_s (cmd, sizeof (cmd) - 1, "\"%s\" \"%s\" vlc://quit"

                 " %s --gain=%.10g --drawable-hwnd=%" PRIu64 " --video-title=\"%s\" --logfile=%s"

                 " --live-caching=500 --network-caching=500 --quiet-synchro --no-embedded-video --file-logging"

                 " --ignore-config --reset-config --no-one-instance --play-and-exit"
                 " --intf=dummy --dummy-quiet --quiet --no-video-deco --no-video-title-show --no-stats --no-sub-autodetect-file"
                 " --no-disable-screensaver --no-snapshot-preview --no-auto-preparse --no-mouse-events --no-keyboard-events",

                 vlcPath, (*fileName? fileName : "fileName"), sZoom, gain, (uint64_t) wnd, processUID, _txLogName) < (int) sizeof (cmd) asserted;

$   txOutputDebugPrintf ("txPlayVideo (%d, %d, %d, %d, \"%s\", %lg, %lg, %p): [%s]\n\n",
                         x, y, width, height, fileName, zoom, gain, wnd, cmd);
$   if (!*fileName)
        {
        if (child) {$ txDestroyWindow (child); }
$       return (intptr_t) cmd;
        }

$   if (!strstr (fileName, "://") && _access (fileName, 0) != 0)
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå íàéäåí ôàéë \"%s\"", fileName), errPos));

        if (child) {$ txDestroyWindow (child); }
$       return INT_MIN+1;
        }

    // Run VLC, run

$   PROCESS_INFORMATION vlc   = {};
$   STARTUPINFO         start = { sizeof (start) };
$   DWORD               ret   = 0;

$   if (CreateProcess (NULL, cmd, NULL, NULL, true, 0, NULL, NULL, &start, &vlc) &&
        vlc.hProcess && vlc.hThread)
        {
$       if (child)
            {
$           assert (wnd == child);
$           SetWindowLongPtr (wnd, GWLP_USERDATA, (LONG_PTR) vlc.hProcess);
            }

$       if (!async)
            {
$           WaitForSingleObject (vlc.hProcess, INFINITE);
$           GetExitCodeProcess  (vlc.hProcess, &ret) asserted;
            }

$       if (!child)
            {
$           CloseHandle (vlc.hProcess) asserted;
            }

$       CloseHandle (vlc.hThread) asserted;

$       return (async? (intptr_t) wnd : (ret == 0)? time - GetTickCount() : - (int) ret);
        }
    else
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Îøèáêà çàïóñêà VideoLAN (%s)", cmd), errPos));
$       if (child)
            {$ txDestroyWindow (child); }

$       return INT_MIN+4;
        }

    #undef PROCESS_UID_
    }

//-----------------------------------------------------------------------------------------------------------------

inline intptr_t txPlayVideo (const char fileName[], double zoom /*= 0*/, double gain /*= 0*/, HWND wnd /*= txWindow()*/)
    {
$1  return txPlayVideo (0, 0, 0, 0, fileName, zoom, gain, wnd);
    }

//-----------------------------------------------------------------------------------------------------------------

LRESULT CALLBACK _txPlayVideo_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
    const UINT_PTR checkTimer = 1;

    switch (msg)
        {
        case WM_CREATE:
            {
$1          SetTimer  (wnd, checkTimer, 5*_txWindowUpdateInterval, NULL) asserted;
            }
            break;

        case WM_DESTROY:
            {
$1          KillTimer (wnd, checkTimer) asserted;

$           HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

$           if (vlc)
                {
$               Win32::TerminateProcess (vlc, 0);

$               CloseHandle (vlc) asserted;

$               SetWindowLongPtr (wnd, GWLP_USERDATA, 0);
                }
            }
            break;

        case WM_TIMER:
            {
            HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

            if (vlc && WaitForSingleObject (vlc, 0) != WAIT_TIMEOUT)
                {
$1              DestroyWindow (wnd) asserted;
                }
            }
            break;

        default:
            break;
        }

    return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txPlayVideo_FindVLC()
    {
$1  static char vlcPath [MAX_PATH] = "";

$   if (SearchPath (NULL, "vlc.bat", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (SearchPath (NULL, "vlc.exe", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", NULL, vlcPath, sizeof (vlcPath)))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", "InstallDir", vlcPath, sizeof (vlcPath)))
        {
$       strncat_s (vlcPath, sizeof (vlcPath) - 1, "\\vlc.exe", INT_MAX);

        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files"    "\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   return NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// +--<<< Ýòî âðÿä ëè èìååò îòíîøåíèå ê òîìó, ÷òî âû èùåòå :)
// V      Ïîëåçíî ñìîòðåòü íå òîëüêî ââåðõ, íî è âíèç

WNDPROC txSetWindowsHook (WNDPROC wndProc /*= NULL*/)
    {
$1  WNDPROC old = _txAltWndProc; _txAltWndProc = wndProc;
$   return  old;
    }

//-----------------------------------------------------------------------------------------------------------------

//     +--<<< À ýòî, íàêîíåö, èñêîìîå îïðåäåëåíèå ýòîé ôóíêöèè.
//     |      Ñìîòðèòå ïî ñòîðîíàì! Íóæíàÿ âàì ôóíêöèÿ ãäå-òî ðÿäîì.
//     |
//     v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()
    {
    txMessageBox ("Ýòî çàïëàíèðîâàííàÿ îøèáêà. Òàêîå áûâàåò. Âû õîòåëè âûçâàòü:\n\n"

                  "txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()\n\n"

                  "Õîòü âû äîëãî [êîïèðîâàëè]íàáèðàëè ýòî èìÿ, íà ñàìîì äåëå ýòà ôóíêöèÿ íå ðåàëèçîâàíà. "
                  "Åñòü äðóãàÿ ôóíêöèÿ, êîòîðàÿ óáèðàåò àâòî-ïàóçó â êîíöå ïðîãðàììû, íî â õåëïå ïðî íåå íå íàïèñàíî.\n\n"

                  "Íî íå âñå òàê ïëîõî. Îïðåäåëåíèå íóæíîé ôóíêöèè åñòü â èñõîäíûõ òåêñòàõ TXLib.h, îíî ëåæèò ðÿäîì "
                  "ñ îïðåäåëåíèåì òîé ôóíêöèè ñ äëèííûì íàçâàíèåì, êîòîðóþ âû ñåé÷àñ âûçâàëè.\n\n"

                  "Íàæìèòå â ðåäàêòîðå Ctrl+O, íàéäèòå è îòêðîéòå ôàéë TXLib.h (îí ëåæèò â ïàïêå, êóäà âû "
                  "óñòàíîâèëè TXLib), çàòåì íàæìèòå Ctrl+F è èùèòå \"txIDontWant\". Óäà÷è!\n\n",

                  "Íå ïîëó÷èëîñü", MB_ICONSTOP);

    // The truth is out there... (C++files)

    return false;
    }

//-----------------------------------------------------------------------------------------------------------------

// Bingo! Now you are learned to use the Sources, Luke. And may the Source be with you.

inline bool txDisableAutoPause()
    {
    _txExit = true;
    return true;
    }

// P.S. This library contains more undocumented functions. Search them via "Luke" keyword.

//-----------------------------------------------------------------------------------------------------------------

void _txDump (const void* address, const char name[] /*= "_txDump()"*/, bool pause /*= true*/)
    {
$1  assert (!_txIsBadReadPtr (address));

    const unsigned char* p = (const unsigned char*) address;
$   unsigned x = 0;

$   unsigned attr = txGetConsoleAttr();

$   txSetConsoleAttr (FOREGROUND_WHITE);
$   printf ("\n%*.*s ", (int) sizeof (address) * 2, (int) sizeof (address) * 2, ((name)? name : ""));

$   txSetConsoleAttr (FOREGROUND_YELLOW);
$   for (x = 0; x < 16; x++) printf ("%02X ", x);
$   for (x = 0; x < 16; x++) printf ("%X",    x);

$   const char   isCtrl[] = "\a" "\b" "\n" "\r" "\t" "\0";
$   const char   xlatCh[] =  "·"  "·"  "·"  "·"  "·"  "·";
$   const size_t szCtrl   = sizeof (isCtrl) - 1;

$   int oldCP = GetConsoleOutputCP();

$   for (int y = 0; y < 16; y++, p += 16)
        {
        txSetConsoleAttr (FOREGROUND_YELLOW);

        printf ("\n" "%*p ", (int) sizeof (address) * 2, p);

        int color = FOREGROUND_LIGHTGREEN;

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);
            printf ("%02X ", p[x]);
            }

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);

            char c = p[x];
            const char* ctrl = (const char*) memchr (isCtrl, c, szCtrl);
            if (ctrl) c = xlatCh [ctrl - isCtrl];

            if (ctrl) SetConsoleOutputCP (1251);

            printf ("%c", c);

            if (ctrl) SetConsoleOutputCP (oldCP);
            }
        }

$   txSetConsoleAttr (attr);
$   printf ("\n");

$   if (pause)
        {
$       SetConsoleOutputCP (_TX_CODEPAGE);

$       fprintf (stderr, "[Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]                          CodePage = %5d\n", oldCP);
$       (void)_getch();

$       SetConsoleOutputCP (oldCP);
        }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txStackBackTrace (const char file[] /*= "?"*/, int line /*= 0*/, const char func[] /*= "?"*/,
                        bool readSource /*= true*/)
    {
$1  unsigned attr = txGetConsoleAttr();
$   txSetConsoleAttr (FOREGROUND_LIGHTCYAN);

$   fprintf (stderr, "\n" "--------------------------------------------------\n"
                          "Òðàññèðîâêà ñòåêà èç \"%s\" at %s (%d):\n\n"
                          "%s\n\n"
                          "--------------------------------------------------\n\n",
                          func, file, line, _txCaptureStackBackTrace (1, readSource));

$   txSetConsoleAttr (attr);
    }

//-----------------------------------------------------------------------------------------------------------------

char* txDemangle (const char* mangledName, std::nomeow_t)
    {
$1  if (!mangledName) return NULL;

$   char* typeName = NULL;

    #if defined (_GCC_VER)

$   int err = 1;
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err); (void) err;
    if (typeName) {$ return typeName; }

    #endif

$   unsigned short flags = 0;

$   if (mangledName[0] == '.')
        {
$       mangledName++;
$       flags = 0x2800;  // UNDNAME_32_BIT_DECODE | UNDNAME_TYPE_ONLY
        }

$   typeName = _TX_CALL (Win32::__unDName, (NULL, mangledName, 0, malloc, free, flags));
    if (typeName) {$ return typeName; }

$   return _strdup (mangledName);
    }

//-----------------------------------------------------------------------------------------------------------------

std::string txDemangle (const char* mangledName)
    {
$1  char* typeName = txDemangle (mangledName, std::nomeow);
$   std::string name (typeName? typeName : "");
$   free (typeName);

$   return name;
    }

//-----------------------------------------------------------------------------------------------------------------

double txQueryPerformance()
    {
$1  int maxTime    =  500;
$   int maxSamples =  100;
$   POINT size     = {100, 100};

$   HDC dc = _txBuffer_Create (txWindow(), &size, NULL);
$   assert (dc); if (!dc) return -1;

$   DWORD mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), 1);
$   assert (mask);

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   int samples = 0;
$   while (samples++ < maxSamples)
        {
$       LARGE_INTEGER cur = {};
$       QueryPerformanceCounter (&cur) asserted;

$       double t = 1000.0 * (double) (cur.QuadPart - start.QuadPart) / (double) freq.QuadPart;
$       if (t > maxTime) break;

        // Draw test scene

$       for (int y = 0; y < size.y; y++)
        for (int x = 0; x < size.x; x++)     txSetPixel (x, y, TX_BLACK, dc);

$       for (int y = 0; y < size.y; y += 10)
        for (int x = 0; x < size.x; x += 50) txTextOut  (x, y, "*", dc);

$       txEllipse (0, 0, size.x, size.y, dc);
$       txFloodFill (size.x/2, size.y/2, TX_TRANSPARENT, FLOODFILLSURFACE, dc);

$       txBitBlt (dc, size.x/2,        0, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc,        0, size.y/2) asserted;
$       txBitBlt (dc,        0, size.y/2, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, size.x/2,        0) asserted;
        }

$   mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), mask);
$   assert (mask);

$   _txBuffer_Delete (&dc);

$   return 3.0 * samples / sqrt (1.0 * size.x * size.y);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_TX_CPP11)
template <int txFramesToAverage>
#endif

double txGetFPS (int minFrames)
    {
$1  static LARGE_INTEGER time0 = {}; if (!time0.QuadPart) QueryPerformanceCounter (&time0);
$          LARGE_INTEGER time  = {};                      QueryPerformanceCounter (&time);

$   if (time.QuadPart - time0.QuadPart == 0)
        {$ return 0; }

$   LARGE_INTEGER freq = {}; QueryPerformanceFrequency (&freq);

$   double fps = (double) freq.QuadPart / (double) (time.QuadPart - time0.QuadPart);
$   time0 = time;

$   if (txFramesToAverage == 0) return fps;

$   static double average [txFramesToAverage] = {};
$   static unsigned n = 0;

$   average [n++ % txFramesToAverage] = fps;

$   unsigned nn = MIN (n, (unsigned) sizearr (average));

$   static double median  [txFramesToAverage] = {};
$   std::copy (average, average + nn, median);
$   std::nth_element (median, median + nn/2, median + nn);

$   fps = (median [(nn-1) / 2] + median [nn / 2]) / 2.0;

$   return ((int)n >= MIN (minFrames, txFramesToAverage))? fps : 0;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txExtractColor (COLORREF color, COLORREF component)
    {
$1  switch (component)
        {
        case TX_RED:
        case TX_HUE:        $ return (color >>  0) & 0xFF;

        case TX_GREEN:
        case TX_SATURATION: $ return (color >>  8) & 0xFF;

        case TX_BLUE:
        case TX_LIGHTNESS:  $ return (color >> 16) & 0xFF;

        default:            $ return CLR_INVALID;
        }
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txRGB2HSL (COLORREF rgbColor)
    {
$1  int r = (int) txExtractColor (rgbColor, TX_RED),
        g = (int) txExtractColor (rgbColor, TX_GREEN),
        b = (int) txExtractColor (rgbColor, TX_BLUE);

$   double m1 = MAX (MAX (r, g), b) / 255.0,
           m2 = MIN (MIN (r, g), b) / 255.0,
           dm = m1 - m2,
           sm = m1 + m2,

           ir = r / 255.0,
           ig = g / 255.0,
           ib = b / 255.0,

           ih = 0,
           is = 0,
           il = sm / 2;

$   const double prec = 0.001;

$   if (fabs (dm) < prec)
        {
$       is = dm / ((sm <= 1)? sm : (2-sm));

$       double cr = (m1 - ir) / dm,
               cg = (m1 - ig) / dm,
               cb = (m1 - ib) / dm;

$       if (fabs (ir - m1) < prec) ih =     cb - cg;
$       if (fabs (ig - m1) < prec) ih = 2 + cr - cb;
$       if (fabs (ib - m1) < prec) ih = 4 + cg - cr;
        }

$   ih = (ih >= 0)? ih*60 : ih*60 + 360;

$   return RGB (ROUND (ih / 360 * 255), ROUND (is * 255), ROUND (il * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txHSL2RGB (COLORREF hslColor)
    {
$1  struct xRGB
        {
        static double calc (double h, double m1, double m2)
            {
$           if (h < 0)   h += 360;
$           if (h > 360) h -= 360;

$           return (h <  60)? m1 + (m2-m1) *      h  / 60 :
                   (h < 180)? m2 :
                   (h < 240)? m1 + (m2-m1) * (240-h) / 60 :
                              m1;
            }
        };

$   int h = (int) txExtractColor (hslColor, TX_HUE),
        s = (int) txExtractColor (hslColor, TX_SATURATION),
        l = (int) txExtractColor (hslColor, TX_LIGHTNESS);

$   double ih = h / 255.0 * 360.0,
           il = l / 100.0,
           is = s / 100.0,

           m2 = (il <= 0.5)? il * (1 + is) : il + is - il * is,
           m1 = 2 * il - m2,

           ir = s? xRGB::calc (ih + 120, m1, m2) : il,
           ig = s? xRGB::calc (ih,       m1, m2) : il,
           ib = s? xRGB::calc (ih - 120, m1, m2) : il;

$   return RGB (ROUND (ir * 255), ROUND (ig * 255), ROUND (ib * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (std::nomeow_t, double left, double right)
    {
    return left + (right - left) * ((double) rand() / RAND_MAX);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (std::nomeow_t, Tx x, Ta a, Tb b)
    {
    return a <= x && x <= b;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int random (int range)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return rand() % range;
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (double left, double right)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return random (std::nomeow, left, right);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (Tx x, Ta a, Tb b)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return In (std::nomeow, x, a, b);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const POINT& pt, const RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.x, rect.left, rect.right) &&
           In (std::nomeow, pt.y, rect.top,  rect.bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const COORD& pt, const SMALL_RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.X, rect.Left, rect.Right) &&
           In (std::nomeow, pt.Y, rect.Top,  rect.Bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

void tx_fpreset()
    {
$1  txAutoLock _lock;

$   Win32::_fpreset();

$   unsigned new87 = 0x0008001C;  // _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW

    #if !defined (__CYGWIN__)

$   unsigned old87 = 0;
$   if (_controlfp_s (&old87, 0, 0) == 0)
        {$ (void) _controlfp_s (&old87, old87  & ~new87, 0x0008001F); }  // _MCW_EM

    #else

$   Win32::_controlfp (Win32::_controlfp (0, 0) & ~new87, 0x0008001F);    // _MCW_EM

    #endif
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T zero() { T __zero = {}; return __zero; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txPrintf() implementation
//           Ðåàëèçàöèÿ txPrintf()
//=================================================================================================================

#if defined (_TX_CPP11)

template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                                  const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width,                   const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                precision_t prec, const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args);
                                         void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt);

template <typename T>                    void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int*     arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt);

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg, ArgsT... args)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*') {$ stream << std::setw (width); }
    else {$ TX_ERROR ("\"%%*\" required to setwidth (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '*') {$ stream << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%.*\" required to setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*' && fmt[2] == '.' && fmt[3] == '*') {$ stream << std::setw (width) << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%*.*\" required to setwidth (%d) and setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (!fmt[0]) {$}
    else {$ TX_ERROR ("No argument provided for %% in \"%s\" while printing \"%s\"", fmt, format); }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char*, int, const char*& fmt)
    {
$1  assert (&stream);
$   assert (fmt);

$   while (*fmt)
        {
        if (fmt[0] == '%')
            {
            if (fmt[1] == '%') fmt++;
            else break;
            }

        stream << *fmt++;
        }
$   }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg)
    {
$1  assert (&stream);
$   assert (fmt);

$   if (_TX_ARGUMENT_FAILED (&arg)) return;

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   fmt++;

$   char                    oldFill  = stream.fill (' ');
$   std::ios_base::fmtflags oldFlags = stream.flags();

$   for (;;) switch (*fmt)
        {
        case '-': $ stream << std::left;     fmt++; break;
        case '+': $ stream << std::showpos;  fmt++; break;
        case ' ': $ stream.fill (' ');       fmt++; break;
        case '#': $ stream << std::showbase; fmt++; break;
        case '0': $ stream.fill ('0');       fmt++; break;

        default:  $ goto end;
        }
    end:

$   int width = (*fmt != '*')?                  (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0);
$   int prec  = (*fmt == '.')? (*++fmt != '*')? (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0) : 0;

    if (width) {$ stream << std::setw (width);        }
    if (prec)  {$ stream << std::setprecision (prec); }

$   fmt += strspn (fmt, "hljztL");

$   switch (*fmt)
        {
        case '$':
        case '?': $                                              break;

        case 'd':
        case 'i':
        case 'u': $ stream << std::dec;                          break;

        case 'o': $ stream << std::oct;                          break;

        case 'x': $ stream << std::hex;                          break;
        case 'X': $ stream << std::hex        << std::uppercase; break;

        case 'f': $ stream << std::fixed;                        break;
        case 'F': $ stream << std::fixed      << std::uppercase; break;

        case 'e': $ stream << std::scientific;                   break;
        case 'E': $ stream << std::scientific << std::uppercase; break;

        case 'g': $                                              break;
        case 'G': $ stream                    << std::uppercase; break;

        case 'a': $                                              break;
        case 'A': $ stream                    << std::uppercase; break;

        case 'c':
        case 's':
        case 'p': $                                              break;

        default:  $ TX_ERROR ("Invalid format '%.1s' at \"%s\" while printing %s argument %d in \"%s\"", fmt, fmt, txTypename (arg), n, format); break;
        }

$   fmt++;

    if (&arg) {$ stream << arg;      }
    else      {$ stream << "(null)"; }

$   stream.fill  (oldFill);
$   stream.flags (oldFlags);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int* arg)
    {
$1  assert (fmt);

    if (_TX_ARGUMENT_FAILED (arg)) return;

    if (fmt[0] == '%' && fmt[1] == 'n') {$}
    else {$ TX_ERROR ("\"%%n\" required to store print length in int* argument %d in \"%s\"", n, format); }

$   *arg = (int) stream.str().length();

$   fmt += 2;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T> inline const T&    _txPrintfNormalizeArg (const T&           arg) { if (_TX_ARGUMENT_FAILED (&arg)) {;}          return arg;         }
                      inline const char* _txPrintfNormalizeArg (const std::string& arg) { if (_TX_ARGUMENT_FAILED (&arg)) return NULL; return arg.c_str(); }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (std::ostringstream& stream, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&stream)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   const char* fmt = format;
$   _txPrintF (stream, format, 2, fmt, _txPrintfNormalizeArg (args)...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (char buffer[], size_t size, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&buffer)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   if (size > 0) size--;
$   buffer[size] = 0;

$   if (!size) return 0;

$   std::ostringstream stream;
$   stream.rdbuf() -> pubsetbuf (buffer, size);

$   txPrintf (stream, format, args...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline std::string txFormat (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return "";

$   std::ostringstream stream;

$   txPrintf (stream, format, args...);

$   return stream.str();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   return printf ("%s", txFormat (format, args...) .c_str());
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

       int _txPrintfCheck (const char* format, ...) tx_printfy (1);
inline int _txPrintfCheck (const char*,        ...) { return 0; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txDialog methods implementation
//           Ðåàëèçàöèÿ ìåòîäîâ êëàññà txDialog
//
//           See [1] http://msdn.microsoft.com/ru-ru/library/windows/desktop/ms645389%28v=vs.85%29.aspx
//               [2] http://blogs.msdn.microsoft.com/oldnewthing/20050429-00/?p=35743
//               [3] http://blogs.msdn.microsoft.com/oldnewthing/20040623-00/?p=38753
//=================================================================================================================

txDialog::txDialog () :
    layout_ (NULL)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

txDialog::txDialog (const Layout* layout) :
    layout_ (layout)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

const txDialog::Layout* txDialog::setLayout (const Layout* layout)
    {
$1  assert (layout);

$   return ::std::swap (layout_, layout), layout;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (WORD resourceID)
    {
$1  const char* resName = (char*)(uintptr_t) resourceID;

$   if (!FindResource (NULL, resName, RT_DIALOG)) return TX_DEBUG_ERROR ("Íå íàéäåí ðåñóðñ äèàëîãà %d", resourceID), 0;

$   return DialogBoxParam (NULL, resName, NULL, (DLGPROC) DialogProc_, (LPARAM) this);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (const txDialog::Layout* layout /*= NULL*/, size_t bufsize /*= 0*/)
    {
$1  if (!layout)  layout = layout_;
$   if (!layout)  return TX_DEBUG_ERROR ("Íå óñòàíîâëåí äèíàìè÷åñêèé øàáëîí äèàëîãà"), 0;

$   if (!bufsize) bufsize = 1024;

$   DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$   if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà"), 0;

$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };

$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];

$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }

$   tmpl->cdit = (unsigned short) (i-1);

$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);

$   GlobalFree (tmpl);

$   return res;
    }

//-----------------------------------------------------------------------------------------------------------------

int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;

        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;

            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }

$   return FALSE;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;

$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;

$   WORD* pw = (WORD*) globalMem;

$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;

$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }

$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   return pw;
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;

$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;

$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;

$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }

$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }

$   *pw++ = 0;

$   return pw;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================

#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$

//}
//=================================================================================================================

//! @endcond

//=================================================================================================================
//{          Experimental Debugging macros
//! @name    Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//!          âî âðåìÿ åãî âûïîëíåíèÿ.
//!
//!          Ñäåëàé ïðèÿòíûìè òâîè <i>êðóãëûå ñóòêè 
    // â êîïèðóåìîé êàðòèíêå èëè åãî íàäî èãíîðèðîâàòü. Åñëè â êàðòèíêå ôàêòè÷åñêè åñòü ïðàâèëüíî ïîñòðîåííûé àëüôà-êàíàë    // (ñì. îïèñàíèå ôóíêöèè txAlphaBlend â ñèñòåìå ïîìîùè TXLib), òî ÷åòâåðòûé êîìïîíåíò ñòðóêòóðû íàäî çàäàòü êàê êîíñòàíòó
    // AC_SRC_ALPHA.
    //
    // Åñëè â êàðòèíêå àëüôà-êàíàëà ôàêòè÷åñêè íåò, òî ÷åòâåðòûé ïàðàìåòð íàäî óñòàíîâèòü â 0.
    //
    //  êîäå íèæå ÷åòâåðòûé ïàðàìåòð îïðåäåëÿåòñÿ àâòîìàòè÷åñêè èç âûçîâà Win32::GetObject(), äëÿ óíèâåðñàëüíîñòè ïðèìåíåíèÿ
    // ôóíêöèè txAlphaBlend().
    //
    // Ïîæàëóéñòà, íå íàäî áåçäóìíî êîïèðîâàòü ñåáå â ïðîãðàììó ýòîò êîä. Îñìûñëèòå åãî, è ðåøèòå, áóäåòå ëè âû èñïîëüçîâàòü
    // àëüôà-êàíàë èëè íåò, è óñòàíîâèòå ÷åòâåðòûé ïàðàìåòð ñòðóêòóðû ëèáî AC_SRC_ALPHA, ëèáî 0. Èíà÷å ýòèì êîïèïàñòîì âû
    // ïîðîäèòå íåâíÿòíûé ïàëåíûé êîä è áåçíàäåæíî èñïîðòèòå ñåáå êàðìó. :((
    //
    // Íà äîëëàðû ($) íå îáðàùàéòå âíèìàíèÿ, îíè íóæíû äëÿ îòëàäêè áèáëèîòåêè TXLib. Â âàøåé ïðîãðàììå èõ èñïîëüçîâàòü íå íàäî.
    //
    //                       ____1____   2   ___________3___________     _______________________4________________________
    //                      /         \  |  /                       \   /                                                \.

$   BLENDFUNCTION blend = { AC_SRC_OVER, 0, (BYTE) ROUND (alpha * 255), (BYTE) ((bmap.bmBitsPixel == 32)? AC_SRC_ALPHA : 0) };

    //
    // * Âûçîâ ñòàíäàðòíîé ôóíêöèè Win32::AlphaBlend() *
    //
    // Íèæå - ýòî âûçîâ Win32::AlphaBlend(). Îí òàê óñòðîåí, ÷òî, åñëè âäðóã ÷òî-òî íå ïîëó÷èëîñü (ò.å. Win32::AlphaBlend()
    // âåðíåò 0), òî òîãäà áóäåò âûçâàíà Win32::BitBlt(), êîòîðàÿ ïðîñòî ñêîïèðóåò êàðòèíêó áåç ó÷åòà ïðîçðà÷íîñòè. Ïîãóãëèòå
    // "Windows AlphaBlend function" è ïî÷èòàéòå ïðî åå ïàðàìåòðû.
    //
    // Êàê âèäèòå, îðèãèíàëüíàÿ ôóíêöèÿ èç Win32 ïðèíèìàåò ðàçìåðû íå òîëüêî èñõîäíîé, íî è èòîãîâîé êàðòèíêè, è åñëè îíè íå
    // ñîâïàäàþò, òî êàðòèíêà áóäåò óìåíüøåíà èëè óâåëè÷åíà. TXlib'îâñêàÿ <s>ïàëåíàÿ</s> ôóíêöèÿ txAlphaBlend ïðåäïîëàãàåò, ÷òî
    // ýòè ðàçìåðû âñåãäà ñîâïàäàþò, è ïîýòîìó ïðè ðàáîòå ñ txAlphaBlend() ìàñøòàá áóäåò âñåãäà 1:1. <s>Òàê ñåáå ðåøåíèå, íî</s>
    // ýòî ñäåëàíî äëÿ óïðîùåíèÿ âûçîâà ôóíêöèè txAlphaBlend().

$   if (Win32::AlphaBlend) // Òîëüêî òî, ÷òî ýòè ïàðàìåòðû ïåðåäàþòñÿ îäèíàêîâûìè, íå äàåò âîçìîæíîñòü ìåíÿòü ìàñøòàá êàðòèíêè!   // <<--
        {                  //                           //                                       vvvvv          vvvvvv            // <<--
$       ok &= txGDI (!!(Win32::AlphaBlend (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),          // <<==
                                           sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), blend)), // <<==
                                           destImage);  //                                       ^^^^^          ^^^^^^            // <<--
        }                  //                                                                    |||||          ||||||            // <<--
                           // Ñì. "AlphaBlend function" â Google, èùèòå ñìûñë ïàðàìåòðîâ wSrc è wDest (hSrc è hDest). Äóìàéòå!    // <<--

    else
        {
$       ok &= txGDI (!!(Win32::BitBlt     (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                           sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                           destImage);
$       ok = false;
        }

    //  ýòîé ôóíêöèè ïðîâåðîê è êîììåíòàðèåâ áîëüøå, ÷åì ðàáî÷åãî êîäà, è ýòî êàê áû íàìåêàåò, ÷òî íåòðóäíî ñäåëàòü ñâîþ
    // àíàëîãè÷íóþ ôóíêöèþ áåç îãðàíè÷åíèé ìàñøòàáà îòîáðàæåíèÿ. <s>Åñëè òû äî÷èòàë äî ýòîãî ìåñòà,</s> ïåðåñÿäü ñ èãëû TXLib'à
    // íà ïîâåðõíîñòü GDI Win32, <s>õîòÿ GDI òîæå òàê ñåáå, òàê ÷òî ëó÷øå çàþçàé GDI+, SFML, OpenGL èëè DirectX, áóäåò êðóòî.
    // Õîòÿ ýòî è ñëîæíåå.</s>

    // Íî ïîìíè ïðî ïàëåíûé êîïèïàñò è êàðìó, ñì. âûøå. ß ïðåäóïðåäèë.

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txAlphaBlend (double xDest, double yDest, HDC sourceImage,
                          double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txAlphaBlend (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, alpha);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txUseAlpha (HDC image)
    {
$1  if (_TX_HDC_FAILED (image)) return NULL;

$   HBITMAP bitmap = (HBITMAP) Win32::GetCurrentObject (image, OBJ_BITMAP);
$   if (!bitmap) return NULL;

$   DIBSECTION dib = {};
$   Win32::GetObject (bitmap, sizeof (dib), &dib) asserted;

$   POINT      size = {  dib.dsBm.bmWidth, dib.dsBm.bmHeight };
$   BITMAPINFO info = {{ sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB }};
$   RGBQUAD*   buf  = NULL;

$   bool isDIB = (dib.dsBm.bmPlanes        == 1                    &&
                  dib.dsBm.bmBitsPixel     == sizeof (RGBQUAD) * 8 &&
                  dib.dsBmih.biCompression == DIB_RGB_COLORS       &&
                  dib.dsBm.bmBits);
$   if (!isDIB)
        {
$       buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$       if (!buf) return NULL;

$       Win32::GetDIBits (image, bitmap, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;
        }
    else
        {
$       buf = (RGBQUAD*) dib.dsBm.bmBits;
        }

$   for (int y = 0; y < size.y; y++)
    for (int x = 0; x < size.x; x++)
        {
        RGBQUAD* color = &buf [x + y * size.x];  // Get color at (x, y) within image buffer

        color->rgbRed   = (BYTE) ROUND (color->rgbRed   * color->rgbReserved / 255.0);
        color->rgbGreen = (BYTE) ROUND (color->rgbGreen * color->rgbReserved / 255.0);
        color->rgbBlue  = (BYTE) ROUND (color->rgbBlue  * color->rgbReserved / 255.0);
        }

$   if (!isDIB)
        {
$       Win32::SetDIBitsToDevice (image, 0, 0, size.x, size.y, 0, 0, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;

$       delete[] buf;
        }

$   return image;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSaveImage (const char filename[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (filename)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))       return false;

$   POINT size = txGetExtent (dc);

$   size_t szHdrs = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER),
           szImg  = (size.x * size.y) * sizeof (RGBQUAD);

$   BITMAPFILEHEADER hdr  = { 0x4D42 /* 'MB' */, (DWORD) (szHdrs + szImg), 0, 0, (DWORD) szHdrs };
$   BITMAPINFOHEADER info = { sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB };

$   bool ok = true;

$   RGBQUAD* buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$   ok &= (buf != NULL);

$   if (ok) Win32::GetDIBits (dc, (HBITMAP) Win32::GetCurrentObject (dc, OBJ_BITMAP), 0, size.y,
                              buf, (BITMAPINFO*) &info, DIB_RGB_COLORS) asserted;
$   FILE* f = NULL;
$   if (ok) fopen_s (&f, filename, "wb");
$   ok &= (f != NULL);

$   if (ok) ok &= (fwrite (&hdr,  sizeof (hdr),  1, f) == 1);
$   if (ok) ok &= (fwrite (&info, sizeof (info), 1, f) == 1);
$   if (ok) ok &= (fwrite (buf,   szImg,         1, f) == 1);

$   ok &= (f && fclose (f) == 0);

$   delete[] buf;
$   buf = NULL;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline void txRedrawWindow()
    {
$1  txSleep (0);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txUpdateWindow (int update /*= true*/)
    {
$1  return _txCanvas_SetRefreshLock (update >= 0? !update : -update);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txBegin()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock + 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txEnd()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock - 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

double txSleep (double time)
    {
$1  LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   int lock = _txCanvas_RefreshLock;
$   _txCanvas_RefreshLock = 0;

$   HWND wnd = txWindow();
    if (wnd) {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   Sleep (ROUND ((time >= 0)? time : 0));

$   _txCanvas_RefreshLock = lock;

$   LARGE_INTEGER stop = {};
$   QueryPerformanceCounter (&stop) asserted;

$   return 1000.0 * (double) (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLock (bool wait /*= true*/)
    {
$0  if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);

$   if (wait) {$ return      EnterCriticalSection (&_txCanvas_LockBackBuf), true; }
    else      {$ return !!TryEnterCriticalSection (&_txCanvas_LockBackBuf);       }
    }

//-----------------------------------------------------------------------------------------------------------------

bool txUnlock()
    {
$0  LeaveCriticalSection (&_txCanvas_LockBackBuf);

$   if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T txUnlock (T value)
    {
$1  txUnlock();
$   return value;
    }

//-----------------------------------------------------------------------------------------------------------------

inline POINT txMousePos()
    {
$1  POINT pos = {};
$   GetCursorPos (&pos);

$   if (txWindow())
        {$ ScreenToClient (txWindow(), &pos); }

$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseX()
    {
    return txMousePos() .x;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseY()
    {
    return txMousePos() .y;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txMouseButtons()
    {
$1  return ((GetAsyncKeyState (VK_LBUTTON) & 0x8000) >> 15) |  // MSB to bit 0
           ((GetAsyncKeyState (VK_RBUTTON) & 0x8000) >> 14) |  // MSB to bit 1
           ((GetAsyncKeyState (VK_MBUTTON) & 0x8000) >> 13);   // MSB to bit 2
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetConsoleAttr (unsigned color /*= FOREGROUND_LIGHTGRAY*/)
    {
    unsigned oldAttr = txGetConsoleAttr();

    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), (WORD) color);

    return oldAttr;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txGetConsoleAttr()
    {
    CONSOLE_SCREEN_BUFFER_INFO con = {};
    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);

    return con.wAttributes;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txSetConsoleCursorPos (double x, double y)
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   COORD pos = { (short) ROUND (1.0 * x / fontSz.x + con.srWindow.Left),
                  (short) ROUND (1.0 * y / fontSz.y + con.srWindow.Top ) };

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos) asserted;

$   POINT prev = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return prev;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleCursorPos()
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  pos = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleExtent()
    {
$1  CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  size = { con.srWindow.Right  - con.srWindow.Left + 1,
                    con.srWindow.Bottom - con.srWindow.Top  + 1 };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClearConsole()
    {
$1  HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (out, &con) asserted;

$   COORD start = {con.srWindow.Left, con.srWindow.Top};

$   DWORD len   = (con.srWindow.Right  - con.srWindow.Left + 1) *
                  (con.srWindow.Bottom - con.srWindow.Top  + 1);

$   DWORD written = 0;
$   FillConsoleOutputCharacter (out, 0x20 /*' '*/,    len, start, &written) asserted;
$   FillConsoleOutputAttribute (out, con.wAttributes, len, start, &written) asserted;

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), start) asserted;

$   return written == len;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleFontSize()
    {
$1  Win32::CONSOLE_FONT_INFO font = {0, {8, 16}};

$   _TX_CALL (Win32::GetCurrentConsoleFont, (GetStdHandle (STD_OUTPUT_HANDLE), false, &font));

$   SIZE size = { font.dwFontSize.X, font.dwFontSize.Y };
$   txGDI (Win32::GetTextExtentPoint32 (_txCanvas_BackBuf[1], "W", 1, &size), txDC());

$   POINT sizeFont = { size.cx, size.cy };
$   return sizeFont;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextCursor (bool blink /*= true*/)
    {
$1  bool old = _txConsole_IsBlinking;

$   _txConsole_IsBlinking = blink;

$   return old;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPlaySound (const char filename[] /*= NULL*/, DWORD mode /*= SND_ASYNC*/)
    {
$1  mode |= SND_FILENAME | SND_NODEFAULT | SND_NOWAIT;
$   if (mode & SND_LOOP) mode = (mode & ~SND_SYNC) | SND_ASYNC;

$   if (!filename) mode = SND_PURGE;

$   return !!Win32::PlaySound (filename, NULL, mode);
    }

//-----------------------------------------------------------------------------------------------------------------

int txSpeak (const char* text, ...)
    {
$1  bool verbose = false; (void) verbose;
$   bool async   = false; (void) async;

$   for (; text && *text; text++)
        {
        if      (*text == '\a') {$ async   = true; }
        else if (*text == '\v') {$ verbose = true; }
        else break;
        }

$   char textA [_TX_BUFSIZE] = "You asked to speak empty text. I would rather say that TX Library is cool! Cats rules!";

$   va_list arg; va_start (arg, text);
    if (text && *text) {$ _tx_vsnprintf_s (textA, sizeof (textA) - 1, text, arg); }
$   va_end (arg);

#ifdef TX_USE_SPEAK

    if (text && verbose) {$ printf ("%s", textA); }

$   int time = GetTickCount();

$   static wchar_t textW [_TX_BUFSIZE * sizeof (wchar_t)] = L"";
$   MultiByteToWideChar (_TX_CODEPAGE, 0, textA, -1, textW, sizearr (textW));

$   static ISpVoice* voice = NULL;

$   if (text && !voice)
        {
$       HRESULT res = Win32::CoInitialize (NULL);
        if (res == S_OK) {$ Win32::CoCreateInstance (Win32::CLSID_SpVoice, NULL, CLSCTX_ALL, Win32::IID_ISpVoice, (void**) &voice); }
        }

$   if (text && voice)
        {
$       Win32::_fpreset();
$       voice->Speak (textW, SPF_PERSIST_XML | SPF_PURGEBEFORESPEAK | (async? SPF_ASYNC : 0), NULL);
$       tx_fpreset();
        }

$   if (!text && voice)
        {
$       voice->Release();
$       voice = NULL;

$       Win32::CoUninitialize();
        }

$   return (voice)? GetTickCount() - time : -1;

#else

$   if (text)
        {
$       unsigned oldAttr = txSetConsoleAttr (FOREGROUND_LIGHTRED | BACKGROUND_BLACK);

$       txNotifyIcon (NIIF_ERROR, "txSpeak(): Íå ìîãó ïðîèçíåñòè (íóæåí TX_USE_SPEAK, ñì. TXLib Help)", "\n" "%s", textA);

$       txSetConsoleAttr (oldAttr);
        }

$   return -1;

#endif
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txPlayVideo (int x, int y, int width, int height, const char fileName[],
                      double zoom /*= 0*/, double gain /*= 1*/, HWND wnd /*= txWindow()*/)
    {
$1  if (wnd && wnd == txWindow() && _TX_TXWINDOW_FAILED()) return -1;

$   int time = GetTickCount();

$   static char processUID [64] = "";
    if (!*processUID)
        {
$       FILETIME startTime = {}, null = {};
$       GetProcessTimes (GetCurrentProcess(), &startTime, &null, &null, &null) asserted;
$       _snprintf_s (processUID, sizeof (processUID) - 1, "TXLib[%08X%08X]::txPlayVideo",
                    (unsigned) startTime.dwHighDateTime, (unsigned) startTime.dwLowDateTime) < (int) sizeof (processUID) asserted;
        }

$   if (!fileName)
        {
$       txTaskKill ("vlc.exe", processUID, 0);  // Kill'em all, by command line pattern
$       return 0;
        }

$   static const char* vlcPath = _txPlayVideo_FindVLC();

$   if (!vlcPath || _access (vlcPath, 0) != 0)
        {
$       static int once = false;

$       if (*fileName && !once++)
            {$ txOutputDebugPrintf ("\a" "Íå íàéäåí âèäåîïðîèãðûâàòåëü VideoLAN (vlc.exe). Cêà÷àéòå åãî ñ ñàéòà VideoLAN.org "
                                    "è óñòàíîâèòå. Áåç óñòàíîâêè VideoLAN âèäåî âîñïðîèçâîäèòüñÿ íå áóäåò :(\n\n"
                                    "--\n" "Âñåãäà Âàøà, ôóíêöèÿ " /* êàê áû */ "txPlayVideo()...\n"
                                    "P.S. Ñì. ìîå îïèñàíèå â TXLib Help."); }
$       return INT_MIN;
        }

$   bool async = false;
    if (*fileName == '\a') {$ async = true; fileName++; }

$   RECT rect = {};
    if (wnd) {$ GetClientRect (wnd, &rect); }

    if (!width)  {$ width  = rect.right;  }
    if (!height) {$ height = rect.bottom; }

    // Create a child window to hold the video stream

$   const char* errPos = "ÂÍÅÇÀÏÍÎ";

$   volatile HWND child = NULL;
$   if (wnd && (wnd == txWindow()))
        {
$       const char* wndClass = txRegisterClass ("txPlayVideo", _txPlayVideo_WndProc, 0, NULL_BRUSH, 1);

$       static int number = 1;
$       CREATESTRUCT createData = { NULL, NULL, (HMENU) (size_t) number++, txWindow(), height, width, y, x,
                                    WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, __func__, wndClass };
$       child = txCreateExtraWindow (createData);
$       if (!child)
            {
$           txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                       strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå ìîãó ñîçäàòü îêíî äëÿ âèäåî :("), errPos));
$           return INT_MIN+3;
            }

$       BringWindowToTop (child);

$       wnd = child;
        }

    // Build the command line

    if (!zoom && !wnd) {$ zoom = 1; }

$   char sZoom [64] = "--autoscale";
    if (zoom) {$ _snprintf_s (sZoom, sizeof (sZoom) - 1, "--no-autoscale --zoom=%.10g", zoom) < (int) sizeof (sZoom) asserted; }

$   static char cmd [MAX_PATH*2 + 1024] = "";

$   _snprintf_s (cmd, sizeof (cmd) - 1, "\"%s\" \"%s\" vlc://quit"

                 " %s --gain=%.10g --drawable-hwnd=%" PRIu64 " --video-title=\"%s\" --logfile=%s"

                 " --live-caching=500 --network-caching=500 --quiet-synchro --no-embedded-video --file-logging"

                 " --ignore-config --reset-config --no-one-instance --play-and-exit"
                 " --intf=dummy --dummy-quiet --quiet --no-video-deco --no-video-title-show --no-stats --no-sub-autodetect-file"
                 " --no-disable-screensaver --no-snapshot-preview --no-auto-preparse --no-mouse-events --no-keyboard-events",

                 vlcPath, (*fileName? fileName : "fileName"), sZoom, gain, (uint64_t) wnd, processUID, _txLogName) < (int) sizeof (cmd) asserted;

$   txOutputDebugPrintf ("txPlayVideo (%d, %d, %d, %d, \"%s\", %lg, %lg, %p): [%s]\n\n",
                         x, y, width, height, fileName, zoom, gain, wnd, cmd);
$   if (!*fileName)
        {
        if (child) {$ txDestroyWindow (child); }
$       return (intptr_t) cmd;
        }

$   if (!strstr (fileName, "://") && _access (fileName, 0) != 0)
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå íàéäåí ôàéë \"%s\"", fileName), errPos));

        if (child) {$ txDestroyWindow (child); }
$       return INT_MIN+1;
        }

    // Run VLC, run

$   PROCESS_INFORMATION vlc   = {};
$   STARTUPINFO         start = { sizeof (start) };
$   DWORD               ret   = 0;

$   if (CreateProcess (NULL, cmd, NULL, NULL, true, 0, NULL, NULL, &start, &vlc) &&
        vlc.hProcess && vlc.hThread)
        {
$       if (child)
            {
$           assert (wnd == child);
$           SetWindowLongPtr (wnd, GWLP_USERDATA, (LONG_PTR) vlc.hProcess);
            }

$       if (!async)
            {
$           WaitForSingleObject (vlc.hProcess, INFINITE);
$           GetExitCodeProcess  (vlc.hProcess, &ret) asserted;
            }

$       if (!child)
            {
$           CloseHandle (vlc.hProcess) asserted;
            }

$       CloseHandle (vlc.hThread) asserted;

$       return (async? (intptr_t) wnd : (ret == 0)? time - GetTickCount() : - (int) ret);
        }
    else
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Îøèáêà çàïóñêà VideoLAN (%s)", cmd), errPos));
$       if (child)
            {$ txDestroyWindow (child); }

$       return INT_MIN+4;
        }

    #undef PROCESS_UID_
    }

//-----------------------------------------------------------------------------------------------------------------

inline intptr_t txPlayVideo (const char fileName[], double zoom /*= 0*/, double gain /*= 0*/, HWND wnd /*= txWindow()*/)
    {
$1  return txPlayVideo (0, 0, 0, 0, fileName, zoom, gain, wnd);
    }

//-----------------------------------------------------------------------------------------------------------------

LRESULT CALLBACK _txPlayVideo_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
    const UINT_PTR checkTimer = 1;

    switch (msg)
        {
        case WM_CREATE:
            {
$1          SetTimer  (wnd, checkTimer, 5*_txWindowUpdateInterval, NULL) asserted;
            }
            break;

        case WM_DESTROY:
            {
$1          KillTimer (wnd, checkTimer) asserted;

$           HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

$           if (vlc)
                {
$               Win32::TerminateProcess (vlc, 0);

$               CloseHandle (vlc) asserted;

$               SetWindowLongPtr (wnd, GWLP_USERDATA, 0);
                }
            }
            break;

        case WM_TIMER:
            {
            HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

            if (vlc && WaitForSingleObject (vlc, 0) != WAIT_TIMEOUT)
                {
$1              DestroyWindow (wnd) asserted;
                }
            }
            break;

        default:
            break;
        }

    return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txPlayVideo_FindVLC()
    {
$1  static char vlcPath [MAX_PATH] = "";

$   if (SearchPath (NULL, "vlc.bat", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (SearchPath (NULL, "vlc.exe", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", NULL, vlcPath, sizeof (vlcPath)))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", "InstallDir", vlcPath, sizeof (vlcPath)))
        {
$       strncat_s (vlcPath, sizeof (vlcPath) - 1, "\\vlc.exe", INT_MAX);

        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files"    "\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   return NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// +--<<< Ýòî âðÿä ëè èìååò îòíîøåíèå ê òîìó, ÷òî âû èùåòå :)
// V      Ïîëåçíî ñìîòðåòü íå òîëüêî ââåðõ, íî è âíèç

WNDPROC txSetWindowsHook (WNDPROC wndProc /*= NULL*/)
    {
$1  WNDPROC old = _txAltWndProc; _txAltWndProc = wndProc;
$   return  old;
    }

//-----------------------------------------------------------------------------------------------------------------

//     +--<<< À ýòî, íàêîíåö, èñêîìîå îïðåäåëåíèå ýòîé ôóíêöèè.
//     |      Ñìîòðèòå ïî ñòîðîíàì! Íóæíàÿ âàì ôóíêöèÿ ãäå-òî ðÿäîì.
//     |
//     v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()
    {
    txMessageBox ("Ýòî çàïëàíèðîâàííàÿ îøèáêà. Òàêîå áûâàåò. Âû õîòåëè âûçâàòü:\n\n"

                  "txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()\n\n"

                  "Õîòü âû äîëãî [êîïèðîâàëè]íàáèðàëè ýòî èìÿ, íà ñàìîì äåëå ýòà ôóíêöèÿ íå ðåàëèçîâàíà. "
                  "Åñòü äðóãàÿ ôóíêöèÿ, êîòîðàÿ óáèðàåò àâòî-ïàóçó â êîíöå ïðîãðàììû, íî â õåëïå ïðî íåå íå íàïèñàíî.\n\n"

                  "Íî íå âñå òàê ïëîõî. Îïðåäåëåíèå íóæíîé ôóíêöèè åñòü â èñõîäíûõ òåêñòàõ TXLib.h, îíî ëåæèò ðÿäîì "
                  "ñ îïðåäåëåíèåì òîé ôóíêöèè ñ äëèííûì íàçâàíèåì, êîòîðóþ âû ñåé÷àñ âûçâàëè.\n\n"

                  "Íàæìèòå â ðåäàêòîðå Ctrl+O, íàéäèòå è îòêðîéòå ôàéë TXLib.h (îí ëåæèò â ïàïêå, êóäà âû "
                  "óñòàíîâèëè TXLib), çàòåì íàæìèòå Ctrl+F è èùèòå \"txIDontWant\". Óäà÷è!\n\n",

                  "Íå ïîëó÷èëîñü", MB_ICONSTOP);

    // The truth is out there... (C++files)

    return false;
    }

//-----------------------------------------------------------------------------------------------------------------

// Bingo! Now you are learned to use the Sources, Luke. And may the Source be with you.

inline bool txDisableAutoPause()
    {
    _txExit = true;
    return true;
    }

// P.S. This library contains more undocumented functions. Search them via "Luke" keyword.

//-----------------------------------------------------------------------------------------------------------------

void _txDump (const void* address, const char name[] /*= "_txDump()"*/, bool pause /*= true*/)
    {
$1  assert (!_txIsBadReadPtr (address));

    const unsigned char* p = (const unsigned char*) address;
$   unsigned x = 0;

$   unsigned attr = txGetConsoleAttr();

$   txSetConsoleAttr (FOREGROUND_WHITE);
$   printf ("\n%*.*s ", (int) sizeof (address) * 2, (int) sizeof (address) * 2, ((name)? name : ""));

$   txSetConsoleAttr (FOREGROUND_YELLOW);
$   for (x = 0; x < 16; x++) printf ("%02X ", x);
$   for (x = 0; x < 16; x++) printf ("%X",    x);

$   const char   isCtrl[] = "\a" "\b" "\n" "\r" "\t" "\0";
$   const char   xlatCh[] =  "·"  "·"  "·"  "·"  "·"  "·";
$   const size_t szCtrl   = sizeof (isCtrl) - 1;

$   int oldCP = GetConsoleOutputCP();

$   for (int y = 0; y < 16; y++, p += 16)
        {
        txSetConsoleAttr (FOREGROUND_YELLOW);

        printf ("\n" "%*p ", (int) sizeof (address) * 2, p);

        int color = FOREGROUND_LIGHTGREEN;

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);
            printf ("%02X ", p[x]);
            }

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);

            char c = p[x];
            const char* ctrl = (const char*) memchr (isCtrl, c, szCtrl);
            if (ctrl) c = xlatCh [ctrl - isCtrl];

            if (ctrl) SetConsoleOutputCP (1251);

            printf ("%c", c);

            if (ctrl) SetConsoleOutputCP (oldCP);
            }
        }

$   txSetConsoleAttr (attr);
$   printf ("\n");

$   if (pause)
        {
$       SetConsoleOutputCP (_TX_CODEPAGE);

$       fprintf (stderr, "[Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]                          CodePage = %5d\n", oldCP);
$       (void)_getch();

$       SetConsoleOutputCP (oldCP);
        }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txStackBackTrace (const char file[] /*= "?"*/, int line /*= 0*/, const char func[] /*= "?"*/,
                        bool readSource /*= true*/)
    {
$1  unsigned attr = txGetConsoleAttr();
$   txSetConsoleAttr (FOREGROUND_LIGHTCYAN);

$   fprintf (stderr, "\n" "--------------------------------------------------\n"
                          "Òðàññèðîâêà ñòåêà èç \"%s\" at %s (%d):\n\n"
                          "%s\n\n"
                          "--------------------------------------------------\n\n",
                          func, file, line, _txCaptureStackBackTrace (1, readSource));

$   txSetConsoleAttr (attr);
    }

//-----------------------------------------------------------------------------------------------------------------

char* txDemangle (const char* mangledName, std::nomeow_t)
    {
$1  if (!mangledName) return NULL;

$   char* typeName = NULL;

    #if defined (_GCC_VER)

$   int err = 1;
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err); (void) err;
    if (typeName) {$ return typeName; }

    #endif

$   unsigned short flags = 0;

$   if (mangledName[0] == '.')
        {
$       mangledName++;
$       flags = 0x2800;  // UNDNAME_32_BIT_DECODE | UNDNAME_TYPE_ONLY
        }

$   typeName = _TX_CALL (Win32::__unDName, (NULL, mangledName, 0, malloc, free, flags));
    if (typeName) {$ return typeName; }

$   return _strdup (mangledName);
    }

//-----------------------------------------------------------------------------------------------------------------

std::string txDemangle (const char* mangledName)
    {
$1  char* typeName = txDemangle (mangledName, std::nomeow);
$   std::string name (typeName? typeName : "");
$   free (typeName);

$   return name;
    }

//-----------------------------------------------------------------------------------------------------------------

double txQueryPerformance()
    {
$1  int maxTime    =  500;
$   int maxSamples =  100;
$   POINT size     = {100, 100};

$   HDC dc = _txBuffer_Create (txWindow(), &size, NULL);
$   assert (dc); if (!dc) return -1;

$   DWORD mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), 1);
$   assert (mask);

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   int samples = 0;
$   while (samples++ < maxSamples)
        {
$       LARGE_INTEGER cur = {};
$       QueryPerformanceCounter (&cur) asserted;

$       double t = 1000.0 * (double) (cur.QuadPart - start.QuadPart) / (double) freq.QuadPart;
$       if (t > maxTime) break;

        // Draw test scene

$       for (int y = 0; y < size.y; y++)
        for (int x = 0; x < size.x; x++)     txSetPixel (x, y, TX_BLACK, dc);

$       for (int y = 0; y < size.y; y += 10)
        for (int x = 0; x < size.x; x += 50) txTextOut  (x, y, "*", dc);

$       txEllipse (0, 0, size.x, size.y, dc);
$       txFloodFill (size.x/2, size.y/2, TX_TRANSPARENT, FLOODFILLSURFACE, dc);

$       txBitBlt (dc, size.x/2,        0, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc,        0, size.y/2) asserted;
$       txBitBlt (dc,        0, size.y/2, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, size.x/2,        0) asserted;
        }

$   mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), mask);
$   assert (mask);

$   _txBuffer_Delete (&dc);

$   return 3.0 * samples / sqrt (1.0 * size.x * size.y);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_TX_CPP11)
template <int txFramesToAverage>
#endif

double txGetFPS (int minFrames)
    {
$1  static LARGE_INTEGER time0 = {}; if (!time0.QuadPart) QueryPerformanceCounter (&time0);
$          LARGE_INTEGER time  = {};                      QueryPerformanceCounter (&time);

$   if (time.QuadPart - time0.QuadPart == 0)
        {$ return 0; }

$   LARGE_INTEGER freq = {}; QueryPerformanceFrequency (&freq);

$   double fps = (double) freq.QuadPart / (double) (time.QuadPart - time0.QuadPart);
$   time0 = time;

$   if (txFramesToAverage == 0) return fps;

$   static double average [txFramesToAverage] = {};
$   static unsigned n = 0;

$   average [n++ % txFramesToAverage] = fps;

$   unsigned nn = MIN (n, (unsigned) sizearr (average));

$   static double median  [txFramesToAverage] = {};
$   std::copy (average, average + nn, median);
$   std::nth_element (median, median + nn/2, median + nn);

$   fps = (median [(nn-1) / 2] + median [nn / 2]) / 2.0;

$   return ((int)n >= MIN (minFrames, txFramesToAverage))? fps : 0;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txExtractColor (COLORREF color, COLORREF component)
    {
$1  switch (component)
        {
        case TX_RED:
        case TX_HUE:        $ return (color >>  0) & 0xFF;

        case TX_GREEN:
        case TX_SATURATION: $ return (color >>  8) & 0xFF;

        case TX_BLUE:
        case TX_LIGHTNESS:  $ return (color >> 16) & 0xFF;

        default:            $ return CLR_INVALID;
        }
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txRGB2HSL (COLORREF rgbColor)
    {
$1  int r = (int) txExtractColor (rgbColor, TX_RED),
        g = (int) txExtractColor (rgbColor, TX_GREEN),
        b = (int) txExtractColor (rgbColor, TX_BLUE);

$   double m1 = MAX (MAX (r, g), b) / 255.0,
           m2 = MIN (MIN (r, g), b) / 255.0,
           dm = m1 - m2,
           sm = m1 + m2,

           ir = r / 255.0,
           ig = g / 255.0,
           ib = b / 255.0,

           ih = 0,
           is = 0,
           il = sm / 2;

$   const double prec = 0.001;

$   if (fabs (dm) < prec)
        {
$       is = dm / ((sm <= 1)? sm : (2-sm));

$       double cr = (m1 - ir) / dm,
               cg = (m1 - ig) / dm,
               cb = (m1 - ib) / dm;

$       if (fabs (ir - m1) < prec) ih =     cb - cg;
$       if (fabs (ig - m1) < prec) ih = 2 + cr - cb;
$       if (fabs (ib - m1) < prec) ih = 4 + cg - cr;
        }

$   ih = (ih >= 0)? ih*60 : ih*60 + 360;

$   return RGB (ROUND (ih / 360 * 255), ROUND (is * 255), ROUND (il * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txHSL2RGB (COLORREF hslColor)
    {
$1  struct xRGB
        {
        static double calc (double h, double m1, double m2)
            {
$           if (h < 0)   h += 360;
$           if (h > 360) h -= 360;

$           return (h <  60)? m1 + (m2-m1) *      h  / 60 :
                   (h < 180)? m2 :
                   (h < 240)? m1 + (m2-m1) * (240-h) / 60 :
                              m1;
            }
        };

$   int h = (int) txExtractColor (hslColor, TX_HUE),
        s = (int) txExtractColor (hslColor, TX_SATURATION),
        l = (int) txExtractColor (hslColor, TX_LIGHTNESS);

$   double ih = h / 255.0 * 360.0,
           il = l / 100.0,
           is = s / 100.0,

           m2 = (il <= 0.5)? il * (1 + is) : il + is - il * is,
           m1 = 2 * il - m2,

           ir = s? xRGB::calc (ih + 120, m1, m2) : il,
           ig = s? xRGB::calc (ih,       m1, m2) : il,
           ib = s? xRGB::calc (ih - 120, m1, m2) : il;

$   return RGB (ROUND (ir * 255), ROUND (ig * 255), ROUND (ib * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (std::nomeow_t, double left, double right)
    {
    return left + (right - left) * ((double) rand() / RAND_MAX);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (std::nomeow_t, Tx x, Ta a, Tb b)
    {
    return a <= x && x <= b;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int random (int range)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return rand() % range;
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (double left, double right)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return random (std::nomeow, left, right);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (Tx x, Ta a, Tb b)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return In (std::nomeow, x, a, b);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const POINT& pt, const RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.x, rect.left, rect.right) &&
           In (std::nomeow, pt.y, rect.top,  rect.bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const COORD& pt, const SMALL_RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.X, rect.Left, rect.Right) &&
           In (std::nomeow, pt.Y, rect.Top,  rect.Bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

void tx_fpreset()
    {
$1  txAutoLock _lock;

$   Win32::_fpreset();

$   unsigned new87 = 0x0008001C;  // _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW

    #if !defined (__CYGWIN__)

$   unsigned old87 = 0;
$   if (_controlfp_s (&old87, 0, 0) == 0)
        {$ (void) _controlfp_s (&old87, old87  & ~new87, 0x0008001F); }  // _MCW_EM

    #else

$   Win32::_controlfp (Win32::_controlfp (0, 0) & ~new87, 0x0008001F);    // _MCW_EM

    #endif
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T zero() { T __zero = {}; return __zero; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txPrintf() implementation
//           Ðåàëèçàöèÿ txPrintf()
//=================================================================================================================

#if defined (_TX_CPP11)

template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                                  const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width,                   const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                precision_t prec, const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args);
                                         void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt);

template <typename T>                    void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int*     arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt);

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg, ArgsT... args)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*') {$ stream << std::setw (width); }
    else {$ TX_ERROR ("\"%%*\" required to setwidth (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '*') {$ stream << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%.*\" required to setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*' && fmt[2] == '.' && fmt[3] == '*') {$ stream << std::setw (width) << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%*.*\" required to setwidth (%d) and setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (!fmt[0]) {$}
    else {$ TX_ERROR ("No argument provided for %% in \"%s\" while printing \"%s\"", fmt, format); }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char*, int, const char*& fmt)
    {
$1  assert (&stream);
$   assert (fmt);

$   while (*fmt)
        {
        if (fmt[0] == '%')
            {
            if (fmt[1] == '%') fmt++;
            else break;
            }

        stream << *fmt++;
        }
$   }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg)
    {
$1  assert (&stream);
$   assert (fmt);

$   if (_TX_ARGUMENT_FAILED (&arg)) return;

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   fmt++;

$   char                    oldFill  = stream.fill (' ');
$   std::ios_base::fmtflags oldFlags = stream.flags();

$   for (;;) switch (*fmt)
        {
        case '-': $ stream << std::left;     fmt++; break;
        case '+': $ stream << std::showpos;  fmt++; break;
        case ' ': $ stream.fill (' ');       fmt++; break;
        case '#': $ stream << std::showbase; fmt++; break;
        case '0': $ stream.fill ('0');       fmt++; break;

        default:  $ goto end;
        }
    end:

$   int width = (*fmt != '*')?                  (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0);
$   int prec  = (*fmt == '.')? (*++fmt != '*')? (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0) : 0;

    if (width) {$ stream << std::setw (width);        }
    if (prec)  {$ stream << std::setprecision (prec); }

$   fmt += strspn (fmt, "hljztL");

$   switch (*fmt)
        {
        case '$':
        case '?': $                                              break;

        case 'd':
        case 'i':
        case 'u': $ stream << std::dec;                          break;

        case 'o': $ stream << std::oct;                          break;

        case 'x': $ stream << std::hex;                          break;
        case 'X': $ stream << std::hex        << std::uppercase; break;

        case 'f': $ stream << std::fixed;                        break;
        case 'F': $ stream << std::fixed      << std::uppercase; break;

        case 'e': $ stream << std::scientific;                   break;
        case 'E': $ stream << std::scientific << std::uppercase; break;

        case 'g': $                                              break;
        case 'G': $ stream                    << std::uppercase; break;

        case 'a': $                                              break;
        case 'A': $ stream                    << std::uppercase; break;

        case 'c':
        case 's':
        case 'p': $                                              break;

        default:  $ TX_ERROR ("Invalid format '%.1s' at \"%s\" while printing %s argument %d in \"%s\"", fmt, fmt, txTypename (arg), n, format); break;
        }

$   fmt++;

    if (&arg) {$ stream << arg;      }
    else      {$ stream << "(null)"; }

$   stream.fill  (oldFill);
$   stream.flags (oldFlags);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int* arg)
    {
$1  assert (fmt);

    if (_TX_ARGUMENT_FAILED (arg)) return;

    if (fmt[0] == '%' && fmt[1] == 'n') {$}
    else {$ TX_ERROR ("\"%%n\" required to store print length in int* argument %d in \"%s\"", n, format); }

$   *arg = (int) stream.str().length();

$   fmt += 2;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T> inline const T&    _txPrintfNormalizeArg (const T&           arg) { if (_TX_ARGUMENT_FAILED (&arg)) {;}          return arg;         }
                      inline const char* _txPrintfNormalizeArg (const std::string& arg) { if (_TX_ARGUMENT_FAILED (&arg)) return NULL; return arg.c_str(); }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (std::ostringstream& stream, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&stream)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   const char* fmt = format;
$   _txPrintF (stream, format, 2, fmt, _txPrintfNormalizeArg (args)...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (char buffer[], size_t size, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&buffer)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   if (size > 0) size--;
$   buffer[size] = 0;

$   if (!size) return 0;

$   std::ostringstream stream;
$   stream.rdbuf() -> pubsetbuf (buffer, size);

$   txPrintf (stream, format, args...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline std::string txFormat (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return "";

$   std::ostringstream stream;

$   txPrintf (stream, format, args...);

$   return stream.str();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   return printf ("%s", txFormat (format, args...) .c_str());
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

       int _txPrintfCheck (const char* format, ...) tx_printfy (1);
inline int _txPrintfCheck (const char*,        ...) { return 0; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txDialog methods implementation
//           Ðåàëèçàöèÿ ìåòîäîâ êëàññà txDialog
//
//           See [1] http://msdn.microsoft.com/ru-ru/library/windows/desktop/ms645389%28v=vs.85%29.aspx
//               [2] http://blogs.msdn.microsoft.com/oldnewthing/20050429-00/?p=35743
//               [3] http://blogs.msdn.microsoft.com/oldnewthing/20040623-00/?p=38753
//=================================================================================================================

txDialog::txDialog () :
    layout_ (NULL)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

txDialog::txDialog (const Layout* layout) :
    layout_ (layout)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

const txDialog::Layout* txDialog::setLayout (const Layout* layout)
    {
$1  assert (layout);

$   return ::std::swap (layout_, layout), layout;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (WORD resourceID)
    {
$1  const char* resName = (char*)(uintptr_t) resourceID;

$   if (!FindResource (NULL, resName, RT_DIALOG)) return TX_DEBUG_ERROR ("Íå íàéäåí ðåñóðñ äèàëîãà %d", resourceID), 0;

$   return DialogBoxParam (NULL, resName, NULL, (DLGPROC) DialogProc_, (LPARAM) this);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (const txDialog::Layout* layout /*= NULL*/, size_t bufsize /*= 0*/)
    {
$1  if (!layout)  layout = layout_;
$   if (!layout)  return TX_DEBUG_ERROR ("Íå óñòàíîâëåí äèíàìè÷åñêèé øàáëîí äèàëîãà"), 0;

$   if (!bufsize) bufsize = 1024;

$   DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$   if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà"), 0;

$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };

$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];

$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }

$   tmpl->cdit = (unsigned short) (i-1);

$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);

$   GlobalFree (tmpl);

$   return res;
    }

//-----------------------------------------------------------------------------------------------------------------

int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;

        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;

            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }

$   return FALSE;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;

$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;

$   WORD* pw = (WORD*) globalMem;

$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;

$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }

$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   return pw;
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;

$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;

$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;

$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }

$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }

$   *pw++ = 0;

$   return pw;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================

#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$

//}
//=================================================================================================================

//! @endcond

//=================================================================================================================
//{          Experimental Debugging macros
//! @name    Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//!          âî âðåìÿ åãî âûïîëíåíèÿ.
//!
//!          Ñäåëàé ïðèÿòíûìè òâîè <i>êðóãëûå ñóòêè 
    // (ñì. îïèñàíèå ôóíêöèè txAlphaBlend â ñèñòåìå ïîìîùè TXLib), òî ÷åòâåðòûé êîìïîíåíò ñòðóêòóðû íàäî çàäàòü êàê êîíñòàíòó    // AC_SRC_ALPHA.
    //
    // Åñëè â êàðòèíêå àëüôà-êàíàëà ôàêòè÷åñêè íåò, òî ÷åòâåðòûé ïàðàìåòð íàäî óñòàíîâèòü â 0.
    //
    //  êîäå íèæå ÷åòâåðòûé ïàðàìåòð îïðåäåëÿåòñÿ àâòîìàòè÷åñêè èç âûçîâà Win32::GetObject(), äëÿ óíèâåðñàëüíîñòè ïðèìåíåíèÿ
    // ôóíêöèè txAlphaBlend().
    //
    // Ïîæàëóéñòà, íå íàäî áåçäóìíî êîïèðîâàòü ñåáå â ïðîãðàììó ýòîò êîä. Îñìûñëèòå åãî, è ðåøèòå, áóäåòå ëè âû èñïîëüçîâàòü
    // àëüôà-êàíàë èëè íåò, è óñòàíîâèòå ÷åòâåðòûé ïàðàìåòð ñòðóêòóðû ëèáî AC_SRC_ALPHA, ëèáî 0. Èíà÷å ýòèì êîïèïàñòîì âû
    // ïîðîäèòå íåâíÿòíûé ïàëåíûé êîä è áåçíàäåæíî èñïîðòèòå ñåáå êàðìó. :((
    //
    // Íà äîëëàðû ($) íå îáðàùàéòå âíèìàíèÿ, îíè íóæíû äëÿ îòëàäêè áèáëèîòåêè TXLib. Â âàøåé ïðîãðàììå èõ èñïîëüçîâàòü íå íàäî.
    //
    //                       ____1____   2   ___________3___________     _______________________4________________________
    //                      /         \  |  /                       \   /                                                \.

$   BLENDFUNCTION blend = { AC_SRC_OVER, 0, (BYTE) ROUND (alpha * 255), (BYTE) ((bmap.bmBitsPixel == 32)? AC_SRC_ALPHA : 0) };

    //
    // * Âûçîâ ñòàíäàðòíîé ôóíêöèè Win32::AlphaBlend() *
    //
    // Íèæå - ýòî âûçîâ Win32::AlphaBlend(). Îí òàê óñòðîåí, ÷òî, åñëè âäðóã ÷òî-òî íå ïîëó÷èëîñü (ò.å. Win32::AlphaBlend()
    // âåðíåò 0), òî òîãäà áóäåò âûçâàíà Win32::BitBlt(), êîòîðàÿ ïðîñòî ñêîïèðóåò êàðòèíêó áåç ó÷åòà ïðîçðà÷íîñòè. Ïîãóãëèòå
    // "Windows AlphaBlend function" è ïî÷èòàéòå ïðî åå ïàðàìåòðû.
    //
    // Êàê âèäèòå, îðèãèíàëüíàÿ ôóíêöèÿ èç Win32 ïðèíèìàåò ðàçìåðû íå òîëüêî èñõîäíîé, íî è èòîãîâîé êàðòèíêè, è åñëè îíè íå
    // ñîâïàäàþò, òî êàðòèíêà áóäåò óìåíüøåíà èëè óâåëè÷åíà. TXlib'îâñêàÿ <s>ïàëåíàÿ</s> ôóíêöèÿ txAlphaBlend ïðåäïîëàãàåò, ÷òî
    // ýòè ðàçìåðû âñåãäà ñîâïàäàþò, è ïîýòîìó ïðè ðàáîòå ñ txAlphaBlend() ìàñøòàá áóäåò âñåãäà 1:1. <s>Òàê ñåáå ðåøåíèå, íî</s>
    // ýòî ñäåëàíî äëÿ óïðîùåíèÿ âûçîâà ôóíêöèè txAlphaBlend().

$   if (Win32::AlphaBlend) // Òîëüêî òî, ÷òî ýòè ïàðàìåòðû ïåðåäàþòñÿ îäèíàêîâûìè, íå äàåò âîçìîæíîñòü ìåíÿòü ìàñøòàá êàðòèíêè!   // <<--
        {                  //                           //                                       vvvvv          vvvvvv            // <<--
$       ok &= txGDI (!!(Win32::AlphaBlend (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),          // <<==
                                           sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), blend)), // <<==
                                           destImage);  //                                       ^^^^^          ^^^^^^            // <<--
        }                  //                                                                    |||||          ||||||            // <<--
                           // Ñì. "AlphaBlend function" â Google, èùèòå ñìûñë ïàðàìåòðîâ wSrc è wDest (hSrc è hDest). Äóìàéòå!    // <<--

    else
        {
$       ok &= txGDI (!!(Win32::BitBlt     (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                           sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                           destImage);
$       ok = false;
        }

    //  ýòîé ôóíêöèè ïðîâåðîê è êîììåíòàðèåâ áîëüøå, ÷åì ðàáî÷åãî êîäà, è ýòî êàê áû íàìåêàåò, ÷òî íåòðóäíî ñäåëàòü ñâîþ
    // àíàëîãè÷íóþ ôóíêöèþ áåç îãðàíè÷åíèé ìàñøòàáà îòîáðàæåíèÿ. <s>Åñëè òû äî÷èòàë äî ýòîãî ìåñòà,</s> ïåðåñÿäü ñ èãëû TXLib'à
    // íà ïîâåðõíîñòü GDI Win32, <s>õîòÿ GDI òîæå òàê ñåáå, òàê ÷òî ëó÷øå çàþçàé GDI+, SFML, OpenGL èëè DirectX, áóäåò êðóòî.
    // Õîòÿ ýòî è ñëîæíåå.</s>

    // Íî ïîìíè ïðî ïàëåíûé êîïèïàñò è êàðìó, ñì. âûøå. ß ïðåäóïðåäèë.

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txAlphaBlend (double xDest, double yDest, HDC sourceImage,
                          double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txAlphaBlend (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, alpha);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txUseAlpha (HDC image)
    {
$1  if (_TX_HDC_FAILED (image)) return NULL;

$   HBITMAP bitmap = (HBITMAP) Win32::GetCurrentObject (image, OBJ_BITMAP);
$   if (!bitmap) return NULL;

$   DIBSECTION dib = {};
$   Win32::GetObject (bitmap, sizeof (dib), &dib) asserted;

$   POINT      size = {  dib.dsBm.bmWidth, dib.dsBm.bmHeight };
$   BITMAPINFO info = {{ sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB }};
$   RGBQUAD*   buf  = NULL;

$   bool isDIB = (dib.dsBm.bmPlanes        == 1                    &&
                  dib.dsBm.bmBitsPixel     == sizeof (RGBQUAD) * 8 &&
                  dib.dsBmih.biCompression == DIB_RGB_COLORS       &&
                  dib.dsBm.bmBits);
$   if (!isDIB)
        {
$       buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$       if (!buf) return NULL;

$       Win32::GetDIBits (image, bitmap, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;
        }
    else
        {
$       buf = (RGBQUAD*) dib.dsBm.bmBits;
        }

$   for (int y = 0; y < size.y; y++)
    for (int x = 0; x < size.x; x++)
        {
        RGBQUAD* color = &buf [x + y * size.x];  // Get color at (x, y) within image buffer

        color->rgbRed   = (BYTE) ROUND (color->rgbRed   * color->rgbReserved / 255.0);
        color->rgbGreen = (BYTE) ROUND (color->rgbGreen * color->rgbReserved / 255.0);
        color->rgbBlue  = (BYTE) ROUND (color->rgbBlue  * color->rgbReserved / 255.0);
        }

$   if (!isDIB)
        {
$       Win32::SetDIBitsToDevice (image, 0, 0, size.x, size.y, 0, 0, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;

$       delete[] buf;
        }

$   return image;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSaveImage (const char filename[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (filename)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))       return false;

$   POINT size = txGetExtent (dc);

$   size_t szHdrs = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER),
           szImg  = (size.x * size.y) * sizeof (RGBQUAD);

$   BITMAPFILEHEADER hdr  = { 0x4D42 /* 'MB' */, (DWORD) (szHdrs + szImg), 0, 0, (DWORD) szHdrs };
$   BITMAPINFOHEADER info = { sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB };

$   bool ok = true;

$   RGBQUAD* buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$   ok &= (buf != NULL);

$   if (ok) Win32::GetDIBits (dc, (HBITMAP) Win32::GetCurrentObject (dc, OBJ_BITMAP), 0, size.y,
                              buf, (BITMAPINFO*) &info, DIB_RGB_COLORS) asserted;
$   FILE* f = NULL;
$   if (ok) fopen_s (&f, filename, "wb");
$   ok &= (f != NULL);

$   if (ok) ok &= (fwrite (&hdr,  sizeof (hdr),  1, f) == 1);
$   if (ok) ok &= (fwrite (&info, sizeof (info), 1, f) == 1);
$   if (ok) ok &= (fwrite (buf,   szImg,         1, f) == 1);

$   ok &= (f && fclose (f) == 0);

$   delete[] buf;
$   buf = NULL;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline void txRedrawWindow()
    {
$1  txSleep (0);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txUpdateWindow (int update /*= true*/)
    {
$1  return _txCanvas_SetRefreshLock (update >= 0? !update : -update);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txBegin()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock + 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txEnd()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock - 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

double txSleep (double time)
    {
$1  LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   int lock = _txCanvas_RefreshLock;
$   _txCanvas_RefreshLock = 0;

$   HWND wnd = txWindow();
    if (wnd) {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   Sleep (ROUND ((time >= 0)? time : 0));

$   _txCanvas_RefreshLock = lock;

$   LARGE_INTEGER stop = {};
$   QueryPerformanceCounter (&stop) asserted;

$   return 1000.0 * (double) (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLock (bool wait /*= true*/)
    {
$0  if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);

$   if (wait) {$ return      EnterCriticalSection (&_txCanvas_LockBackBuf), true; }
    else      {$ return !!TryEnterCriticalSection (&_txCanvas_LockBackBuf);       }
    }

//-----------------------------------------------------------------------------------------------------------------

bool txUnlock()
    {
$0  LeaveCriticalSection (&_txCanvas_LockBackBuf);

$   if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T txUnlock (T value)
    {
$1  txUnlock();
$   return value;
    }

//-----------------------------------------------------------------------------------------------------------------

inline POINT txMousePos()
    {
$1  POINT pos = {};
$   GetCursorPos (&pos);

$   if (txWindow())
        {$ ScreenToClient (txWindow(), &pos); }

$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseX()
    {
    return txMousePos() .x;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseY()
    {
    return txMousePos() .y;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txMouseButtons()
    {
$1  return ((GetAsyncKeyState (VK_LBUTTON) & 0x8000) >> 15) |  // MSB to bit 0
           ((GetAsyncKeyState (VK_RBUTTON) & 0x8000) >> 14) |  // MSB to bit 1
           ((GetAsyncKeyState (VK_MBUTTON) & 0x8000) >> 13);   // MSB to bit 2
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetConsoleAttr (unsigned color /*= FOREGROUND_LIGHTGRAY*/)
    {
    unsigned oldAttr = txGetConsoleAttr();

    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), (WORD) color);

    return oldAttr;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txGetConsoleAttr()
    {
    CONSOLE_SCREEN_BUFFER_INFO con = {};
    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);

    return con.wAttributes;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txSetConsoleCursorPos (double x, double y)
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   COORD pos = { (short) ROUND (1.0 * x / fontSz.x + con.srWindow.Left),
                  (short) ROUND (1.0 * y / fontSz.y + con.srWindow.Top ) };

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos) asserted;

$   POINT prev = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return prev;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleCursorPos()
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  pos = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleExtent()
    {
$1  CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  size = { con.srWindow.Right  - con.srWindow.Left + 1,
                    con.srWindow.Bottom - con.srWindow.Top  + 1 };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClearConsole()
    {
$1  HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (out, &con) asserted;

$   COORD start = {con.srWindow.Left, con.srWindow.Top};

$   DWORD len   = (con.srWindow.Right  - con.srWindow.Left + 1) *
                  (con.srWindow.Bottom - con.srWindow.Top  + 1);

$   DWORD written = 0;
$   FillConsoleOutputCharacter (out, 0x20 /*' '*/,    len, start, &written) asserted;
$   FillConsoleOutputAttribute (out, con.wAttributes, len, start, &written) asserted;

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), start) asserted;

$   return written == len;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleFontSize()
    {
$1  Win32::CONSOLE_FONT_INFO font = {0, {8, 16}};

$   _TX_CALL (Win32::GetCurrentConsoleFont, (GetStdHandle (STD_OUTPUT_HANDLE), false, &font));

$   SIZE size = { font.dwFontSize.X, font.dwFontSize.Y };
$   txGDI (Win32::GetTextExtentPoint32 (_txCanvas_BackBuf[1], "W", 1, &size), txDC());

$   POINT sizeFont = { size.cx, size.cy };
$   return sizeFont;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextCursor (bool blink /*= true*/)
    {
$1  bool old = _txConsole_IsBlinking;

$   _txConsole_IsBlinking = blink;

$   return old;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPlaySound (const char filename[] /*= NULL*/, DWORD mode /*= SND_ASYNC*/)
    {
$1  mode |= SND_FILENAME | SND_NODEFAULT | SND_NOWAIT;
$   if (mode & SND_LOOP) mode = (mode & ~SND_SYNC) | SND_ASYNC;

$   if (!filename) mode = SND_PURGE;

$   return !!Win32::PlaySound (filename, NULL, mode);
    }

//-----------------------------------------------------------------------------------------------------------------

int txSpeak (const char* text, ...)
    {
$1  bool verbose = false; (void) verbose;
$   bool async   = false; (void) async;

$   for (; text && *text; text++)
        {
        if      (*text == '\a') {$ async   = true; }
        else if (*text == '\v') {$ verbose = true; }
        else break;
        }

$   char textA [_TX_BUFSIZE] = "You asked to speak empty text. I would rather say that TX Library is cool! Cats rules!";

$   va_list arg; va_start (arg, text);
    if (text && *text) {$ _tx_vsnprintf_s (textA, sizeof (textA) - 1, text, arg); }
$   va_end (arg);

#ifdef TX_USE_SPEAK

    if (text && verbose) {$ printf ("%s", textA); }

$   int time = GetTickCount();

$   static wchar_t textW [_TX_BUFSIZE * sizeof (wchar_t)] = L"";
$   MultiByteToWideChar (_TX_CODEPAGE, 0, textA, -1, textW, sizearr (textW));

$   static ISpVoice* voice = NULL;

$   if (text && !voice)
        {
$       HRESULT res = Win32::CoInitialize (NULL);
        if (res == S_OK) {$ Win32::CoCreateInstance (Win32::CLSID_SpVoice, NULL, CLSCTX_ALL, Win32::IID_ISpVoice, (void**) &voice); }
        }

$   if (text && voice)
        {
$       Win32::_fpreset();
$       voice->Speak (textW, SPF_PERSIST_XML | SPF_PURGEBEFORESPEAK | (async? SPF_ASYNC : 0), NULL);
$       tx_fpreset();
        }

$   if (!text && voice)
        {
$       voice->Release();
$       voice = NULL;

$       Win32::CoUninitialize();
        }

$   return (voice)? GetTickCount() - time : -1;

#else

$   if (text)
        {
$       unsigned oldAttr = txSetConsoleAttr (FOREGROUND_LIGHTRED | BACKGROUND_BLACK);

$       txNotifyIcon (NIIF_ERROR, "txSpeak(): Íå ìîãó ïðîèçíåñòè (íóæåí TX_USE_SPEAK, ñì. TXLib Help)", "\n" "%s", textA);

$       txSetConsoleAttr (oldAttr);
        }

$   return -1;

#endif
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txPlayVideo (int x, int y, int width, int height, const char fileName[],
                      double zoom /*= 0*/, double gain /*= 1*/, HWND wnd /*= txWindow()*/)
    {
$1  if (wnd && wnd == txWindow() && _TX_TXWINDOW_FAILED()) return -1;

$   int time = GetTickCount();

$   static char processUID [64] = "";
    if (!*processUID)
        {
$       FILETIME startTime = {}, null = {};
$       GetProcessTimes (GetCurrentProcess(), &startTime, &null, &null, &null) asserted;
$       _snprintf_s (processUID, sizeof (processUID) - 1, "TXLib[%08X%08X]::txPlayVideo",
                    (unsigned) startTime.dwHighDateTime, (unsigned) startTime.dwLowDateTime) < (int) sizeof (processUID) asserted;
        }

$   if (!fileName)
        {
$       txTaskKill ("vlc.exe", processUID, 0);  // Kill'em all, by command line pattern
$       return 0;
        }

$   static const char* vlcPath = _txPlayVideo_FindVLC();

$   if (!vlcPath || _access (vlcPath, 0) != 0)
        {
$       static int once = false;

$       if (*fileName && !once++)
            {$ txOutputDebugPrintf ("\a" "Íå íàéäåí âèäåîïðîèãðûâàòåëü VideoLAN (vlc.exe). Cêà÷àéòå åãî ñ ñàéòà VideoLAN.org "
                                    "è óñòàíîâèòå. Áåç óñòàíîâêè VideoLAN âèäåî âîñïðîèçâîäèòüñÿ íå áóäåò :(\n\n"
                                    "--\n" "Âñåãäà Âàøà, ôóíêöèÿ " /* êàê áû */ "txPlayVideo()...\n"
                                    "P.S. Ñì. ìîå îïèñàíèå â TXLib Help."); }
$       return INT_MIN;
        }

$   bool async = false;
    if (*fileName == '\a') {$ async = true; fileName++; }

$   RECT rect = {};
    if (wnd) {$ GetClientRect (wnd, &rect); }

    if (!width)  {$ width  = rect.right;  }
    if (!height) {$ height = rect.bottom; }

    // Create a child window to hold the video stream

$   const char* errPos = "ÂÍÅÇÀÏÍÎ";

$   volatile HWND child = NULL;
$   if (wnd && (wnd == txWindow()))
        {
$       const char* wndClass = txRegisterClass ("txPlayVideo", _txPlayVideo_WndProc, 0, NULL_BRUSH, 1);

$       static int number = 1;
$       CREATESTRUCT createData = { NULL, NULL, (HMENU) (size_t) number++, txWindow(), height, width, y, x,
                                    WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, __func__, wndClass };
$       child = txCreateExtraWindow (createData);
$       if (!child)
            {
$           txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                       strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå ìîãó ñîçäàòü îêíî äëÿ âèäåî :("), errPos));
$           return INT_MIN+3;
            }

$       BringWindowToTop (child);

$       wnd = child;
        }

    // Build the command line

    if (!zoom && !wnd) {$ zoom = 1; }

$   char sZoom [64] = "--autoscale";
    if (zoom) {$ _snprintf_s (sZoom, sizeof (sZoom) - 1, "--no-autoscale --zoom=%.10g", zoom) < (int) sizeof (sZoom) asserted; }

$   static char cmd [MAX_PATH*2 + 1024] = "";

$   _snprintf_s (cmd, sizeof (cmd) - 1, "\"%s\" \"%s\" vlc://quit"

                 " %s --gain=%.10g --drawable-hwnd=%" PRIu64 " --video-title=\"%s\" --logfile=%s"

                 " --live-caching=500 --network-caching=500 --quiet-synchro --no-embedded-video --file-logging"

                 " --ignore-config --reset-config --no-one-instance --play-and-exit"
                 " --intf=dummy --dummy-quiet --quiet --no-video-deco --no-video-title-show --no-stats --no-sub-autodetect-file"
                 " --no-disable-screensaver --no-snapshot-preview --no-auto-preparse --no-mouse-events --no-keyboard-events",

                 vlcPath, (*fileName? fileName : "fileName"), sZoom, gain, (uint64_t) wnd, processUID, _txLogName) < (int) sizeof (cmd) asserted;

$   txOutputDebugPrintf ("txPlayVideo (%d, %d, %d, %d, \"%s\", %lg, %lg, %p): [%s]\n\n",
                         x, y, width, height, fileName, zoom, gain, wnd, cmd);
$   if (!*fileName)
        {
        if (child) {$ txDestroyWindow (child); }
$       return (intptr_t) cmd;
        }

$   if (!strstr (fileName, "://") && _access (fileName, 0) != 0)
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå íàéäåí ôàéë \"%s\"", fileName), errPos));

        if (child) {$ txDestroyWindow (child); }
$       return INT_MIN+1;
        }

    // Run VLC, run

$   PROCESS_INFORMATION vlc   = {};
$   STARTUPINFO         start = { sizeof (start) };
$   DWORD               ret   = 0;

$   if (CreateProcess (NULL, cmd, NULL, NULL, true, 0, NULL, NULL, &start, &vlc) &&
        vlc.hProcess && vlc.hThread)
        {
$       if (child)
            {
$           assert (wnd == child);
$           SetWindowLongPtr (wnd, GWLP_USERDATA, (LONG_PTR) vlc.hProcess);
            }

$       if (!async)
            {
$           WaitForSingleObject (vlc.hProcess, INFINITE);
$           GetExitCodeProcess  (vlc.hProcess, &ret) asserted;
            }

$       if (!child)
            {
$           CloseHandle (vlc.hProcess) asserted;
            }

$       CloseHandle (vlc.hThread) asserted;

$       return (async? (intptr_t) wnd : (ret == 0)? time - GetTickCount() : - (int) ret);
        }
    else
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Îøèáêà çàïóñêà VideoLAN (%s)", cmd), errPos));
$       if (child)
            {$ txDestroyWindow (child); }

$       return INT_MIN+4;
        }

    #undef PROCESS_UID_
    }

//-----------------------------------------------------------------------------------------------------------------

inline intptr_t txPlayVideo (const char fileName[], double zoom /*= 0*/, double gain /*= 0*/, HWND wnd /*= txWindow()*/)
    {
$1  return txPlayVideo (0, 0, 0, 0, fileName, zoom, gain, wnd);
    }

//-----------------------------------------------------------------------------------------------------------------

LRESULT CALLBACK _txPlayVideo_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
    const UINT_PTR checkTimer = 1;

    switch (msg)
        {
        case WM_CREATE:
            {
$1          SetTimer  (wnd, checkTimer, 5*_txWindowUpdateInterval, NULL) asserted;
            }
            break;

        case WM_DESTROY:
            {
$1          KillTimer (wnd, checkTimer) asserted;

$           HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

$           if (vlc)
                {
$               Win32::TerminateProcess (vlc, 0);

$               CloseHandle (vlc) asserted;

$               SetWindowLongPtr (wnd, GWLP_USERDATA, 0);
                }
            }
            break;

        case WM_TIMER:
            {
            HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

            if (vlc && WaitForSingleObject (vlc, 0) != WAIT_TIMEOUT)
                {
$1              DestroyWindow (wnd) asserted;
                }
            }
            break;

        default:
            break;
        }

    return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txPlayVideo_FindVLC()
    {
$1  static char vlcPath [MAX_PATH] = "";

$   if (SearchPath (NULL, "vlc.bat", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (SearchPath (NULL, "vlc.exe", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", NULL, vlcPath, sizeof (vlcPath)))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", "InstallDir", vlcPath, sizeof (vlcPath)))
        {
$       strncat_s (vlcPath, sizeof (vlcPath) - 1, "\\vlc.exe", INT_MAX);

        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files"    "\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   return NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// +--<<< Ýòî âðÿä ëè èìååò îòíîøåíèå ê òîìó, ÷òî âû èùåòå :)
// V      Ïîëåçíî ñìîòðåòü íå òîëüêî ââåðõ, íî è âíèç

WNDPROC txSetWindowsHook (WNDPROC wndProc /*= NULL*/)
    {
$1  WNDPROC old = _txAltWndProc; _txAltWndProc = wndProc;
$   return  old;
    }

//-----------------------------------------------------------------------------------------------------------------

//     +--<<< À ýòî, íàêîíåö, èñêîìîå îïðåäåëåíèå ýòîé ôóíêöèè.
//     |      Ñìîòðèòå ïî ñòîðîíàì! Íóæíàÿ âàì ôóíêöèÿ ãäå-òî ðÿäîì.
//     |
//     v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()
    {
    txMessageBox ("Ýòî çàïëàíèðîâàííàÿ îøèáêà. Òàêîå áûâàåò. Âû õîòåëè âûçâàòü:\n\n"

                  "txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()\n\n"

                  "Õîòü âû äîëãî [êîïèðîâàëè]íàáèðàëè ýòî èìÿ, íà ñàìîì äåëå ýòà ôóíêöèÿ íå ðåàëèçîâàíà. "
                  "Åñòü äðóãàÿ ôóíêöèÿ, êîòîðàÿ óáèðàåò àâòî-ïàóçó â êîíöå ïðîãðàììû, íî â õåëïå ïðî íåå íå íàïèñàíî.\n\n"

                  "Íî íå âñå òàê ïëîõî. Îïðåäåëåíèå íóæíîé ôóíêöèè åñòü â èñõîäíûõ òåêñòàõ TXLib.h, îíî ëåæèò ðÿäîì "
                  "ñ îïðåäåëåíèåì òîé ôóíêöèè ñ äëèííûì íàçâàíèåì, êîòîðóþ âû ñåé÷àñ âûçâàëè.\n\n"

                  "Íàæìèòå â ðåäàêòîðå Ctrl+O, íàéäèòå è îòêðîéòå ôàéë TXLib.h (îí ëåæèò â ïàïêå, êóäà âû "
                  "óñòàíîâèëè TXLib), çàòåì íàæìèòå Ctrl+F è èùèòå \"txIDontWant\". Óäà÷è!\n\n",

                  "Íå ïîëó÷èëîñü", MB_ICONSTOP);

    // The truth is out there... (C++files)

    return false;
    }

//-----------------------------------------------------------------------------------------------------------------

// Bingo! Now you are learned to use the Sources, Luke. And may the Source be with you.

inline bool txDisableAutoPause()
    {
    _txExit = true;
    return true;
    }

// P.S. This library contains more undocumented functions. Search them via "Luke" keyword.

//-----------------------------------------------------------------------------------------------------------------

void _txDump (const void* address, const char name[] /*= "_txDump()"*/, bool pause /*= true*/)
    {
$1  assert (!_txIsBadReadPtr (address));

    const unsigned char* p = (const unsigned char*) address;
$   unsigned x = 0;

$   unsigned attr = txGetConsoleAttr();

$   txSetConsoleAttr (FOREGROUND_WHITE);
$   printf ("\n%*.*s ", (int) sizeof (address) * 2, (int) sizeof (address) * 2, ((name)? name : ""));

$   txSetConsoleAttr (FOREGROUND_YELLOW);
$   for (x = 0; x < 16; x++) printf ("%02X ", x);
$   for (x = 0; x < 16; x++) printf ("%X",    x);

$   const char   isCtrl[] = "\a" "\b" "\n" "\r" "\t" "\0";
$   const char   xlatCh[] =  "·"  "·"  "·"  "·"  "·"  "·";
$   const size_t szCtrl   = sizeof (isCtrl) - 1;

$   int oldCP = GetConsoleOutputCP();

$   for (int y = 0; y < 16; y++, p += 16)
        {
        txSetConsoleAttr (FOREGROUND_YELLOW);

        printf ("\n" "%*p ", (int) sizeof (address) * 2, p);

        int color = FOREGROUND_LIGHTGREEN;

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);
            printf ("%02X ", p[x]);
            }

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);

            char c = p[x];
            const char* ctrl = (const char*) memchr (isCtrl, c, szCtrl);
            if (ctrl) c = xlatCh [ctrl - isCtrl];

            if (ctrl) SetConsoleOutputCP (1251);

            printf ("%c", c);

            if (ctrl) SetConsoleOutputCP (oldCP);
            }
        }

$   txSetConsoleAttr (attr);
$   printf ("\n");

$   if (pause)
        {
$       SetConsoleOutputCP (_TX_CODEPAGE);

$       fprintf (stderr, "[Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]                          CodePage = %5d\n", oldCP);
$       (void)_getch();

$       SetConsoleOutputCP (oldCP);
        }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txStackBackTrace (const char file[] /*= "?"*/, int line /*= 0*/, const char func[] /*= "?"*/,
                        bool readSource /*= true*/)
    {
$1  unsigned attr = txGetConsoleAttr();
$   txSetConsoleAttr (FOREGROUND_LIGHTCYAN);

$   fprintf (stderr, "\n" "--------------------------------------------------\n"
                          "Òðàññèðîâêà ñòåêà èç \"%s\" at %s (%d):\n\n"
                          "%s\n\n"
                          "--------------------------------------------------\n\n",
                          func, file, line, _txCaptureStackBackTrace (1, readSource));

$   txSetConsoleAttr (attr);
    }

//-----------------------------------------------------------------------------------------------------------------

char* txDemangle (const char* mangledName, std::nomeow_t)
    {
$1  if (!mangledName) return NULL;

$   char* typeName = NULL;

    #if defined (_GCC_VER)

$   int err = 1;
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err); (void) err;
    if (typeName) {$ return typeName; }

    #endif

$   unsigned short flags = 0;

$   if (mangledName[0] == '.')
        {
$       mangledName++;
$       flags = 0x2800;  // UNDNAME_32_BIT_DECODE | UNDNAME_TYPE_ONLY
        }

$   typeName = _TX_CALL (Win32::__unDName, (NULL, mangledName, 0, malloc, free, flags));
    if (typeName) {$ return typeName; }

$   return _strdup (mangledName);
    }

//-----------------------------------------------------------------------------------------------------------------

std::string txDemangle (const char* mangledName)
    {
$1  char* typeName = txDemangle (mangledName, std::nomeow);
$   std::string name (typeName? typeName : "");
$   free (typeName);

$   return name;
    }

//-----------------------------------------------------------------------------------------------------------------

double txQueryPerformance()
    {
$1  int maxTime    =  500;
$   int maxSamples =  100;
$   POINT size     = {100, 100};

$   HDC dc = _txBuffer_Create (txWindow(), &size, NULL);
$   assert (dc); if (!dc) return -1;

$   DWORD mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), 1);
$   assert (mask);

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   int samples = 0;
$   while (samples++ < maxSamples)
        {
$       LARGE_INTEGER cur = {};
$       QueryPerformanceCounter (&cur) asserted;

$       double t = 1000.0 * (double) (cur.QuadPart - start.QuadPart) / (double) freq.QuadPart;
$       if (t > maxTime) break;

        // Draw test scene

$       for (int y = 0; y < size.y; y++)
        for (int x = 0; x < size.x; x++)     txSetPixel (x, y, TX_BLACK, dc);

$       for (int y = 0; y < size.y; y += 10)
        for (int x = 0; x < size.x; x += 50) txTextOut  (x, y, "*", dc);

$       txEllipse (0, 0, size.x, size.y, dc);
$       txFloodFill (size.x/2, size.y/2, TX_TRANSPARENT, FLOODFILLSURFACE, dc);

$       txBitBlt (dc, size.x/2,        0, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc,        0, size.y/2) asserted;
$       txBitBlt (dc,        0, size.y/2, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, size.x/2,        0) asserted;
        }

$   mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), mask);
$   assert (mask);

$   _txBuffer_Delete (&dc);

$   return 3.0 * samples / sqrt (1.0 * size.x * size.y);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_TX_CPP11)
template <int txFramesToAverage>
#endif

double txGetFPS (int minFrames)
    {
$1  static LARGE_INTEGER time0 = {}; if (!time0.QuadPart) QueryPerformanceCounter (&time0);
$          LARGE_INTEGER time  = {};                      QueryPerformanceCounter (&time);

$   if (time.QuadPart - time0.QuadPart == 0)
        {$ return 0; }

$   LARGE_INTEGER freq = {}; QueryPerformanceFrequency (&freq);

$   double fps = (double) freq.QuadPart / (double) (time.QuadPart - time0.QuadPart);
$   time0 = time;

$   if (txFramesToAverage == 0) return fps;

$   static double average [txFramesToAverage] = {};
$   static unsigned n = 0;

$   average [n++ % txFramesToAverage] = fps;

$   unsigned nn = MIN (n, (unsigned) sizearr (average));

$   static double median  [txFramesToAverage] = {};
$   std::copy (average, average + nn, median);
$   std::nth_element (median, median + nn/2, median + nn);

$   fps = (median [(nn-1) / 2] + median [nn / 2]) / 2.0;

$   return ((int)n >= MIN (minFrames, txFramesToAverage))? fps : 0;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txExtractColor (COLORREF color, COLORREF component)
    {
$1  switch (component)
        {
        case TX_RED:
        case TX_HUE:        $ return (color >>  0) & 0xFF;

        case TX_GREEN:
        case TX_SATURATION: $ return (color >>  8) & 0xFF;

        case TX_BLUE:
        case TX_LIGHTNESS:  $ return (color >> 16) & 0xFF;

        default:            $ return CLR_INVALID;
        }
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txRGB2HSL (COLORREF rgbColor)
    {
$1  int r = (int) txExtractColor (rgbColor, TX_RED),
        g = (int) txExtractColor (rgbColor, TX_GREEN),
        b = (int) txExtractColor (rgbColor, TX_BLUE);

$   double m1 = MAX (MAX (r, g), b) / 255.0,
           m2 = MIN (MIN (r, g), b) / 255.0,
           dm = m1 - m2,
           sm = m1 + m2,

           ir = r / 255.0,
           ig = g / 255.0,
           ib = b / 255.0,

           ih = 0,
           is = 0,
           il = sm / 2;

$   const double prec = 0.001;

$   if (fabs (dm) < prec)
        {
$       is = dm / ((sm <= 1)? sm : (2-sm));

$       double cr = (m1 - ir) / dm,
               cg = (m1 - ig) / dm,
               cb = (m1 - ib) / dm;

$       if (fabs (ir - m1) < prec) ih =     cb - cg;
$       if (fabs (ig - m1) < prec) ih = 2 + cr - cb;
$       if (fabs (ib - m1) < prec) ih = 4 + cg - cr;
        }

$   ih = (ih >= 0)? ih*60 : ih*60 + 360;

$   return RGB (ROUND (ih / 360 * 255), ROUND (is * 255), ROUND (il * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txHSL2RGB (COLORREF hslColor)
    {
$1  struct xRGB
        {
        static double calc (double h, double m1, double m2)
            {
$           if (h < 0)   h += 360;
$           if (h > 360) h -= 360;

$           return (h <  60)? m1 + (m2-m1) *      h  / 60 :
                   (h < 180)? m2 :
                   (h < 240)? m1 + (m2-m1) * (240-h) / 60 :
                              m1;
            }
        };

$   int h = (int) txExtractColor (hslColor, TX_HUE),
        s = (int) txExtractColor (hslColor, TX_SATURATION),
        l = (int) txExtractColor (hslColor, TX_LIGHTNESS);

$   double ih = h / 255.0 * 360.0,
           il = l / 100.0,
           is = s / 100.0,

           m2 = (il <= 0.5)? il * (1 + is) : il + is - il * is,
           m1 = 2 * il - m2,

           ir = s? xRGB::calc (ih + 120, m1, m2) : il,
           ig = s? xRGB::calc (ih,       m1, m2) : il,
           ib = s? xRGB::calc (ih - 120, m1, m2) : il;

$   return RGB (ROUND (ir * 255), ROUND (ig * 255), ROUND (ib * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (std::nomeow_t, double left, double right)
    {
    return left + (right - left) * ((double) rand() / RAND_MAX);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (std::nomeow_t, Tx x, Ta a, Tb b)
    {
    return a <= x && x <= b;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int random (int range)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return rand() % range;
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (double left, double right)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return random (std::nomeow, left, right);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (Tx x, Ta a, Tb b)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return In (std::nomeow, x, a, b);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const POINT& pt, const RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.x, rect.left, rect.right) &&
           In (std::nomeow, pt.y, rect.top,  rect.bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const COORD& pt, const SMALL_RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.X, rect.Left, rect.Right) &&
           In (std::nomeow, pt.Y, rect.Top,  rect.Bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

void tx_fpreset()
    {
$1  txAutoLock _lock;

$   Win32::_fpreset();

$   unsigned new87 = 0x0008001C;  // _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW

    #if !defined (__CYGWIN__)

$   unsigned old87 = 0;
$   if (_controlfp_s (&old87, 0, 0) == 0)
        {$ (void) _controlfp_s (&old87, old87  & ~new87, 0x0008001F); }  // _MCW_EM

    #else

$   Win32::_controlfp (Win32::_controlfp (0, 0) & ~new87, 0x0008001F);    // _MCW_EM

    #endif
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T zero() { T __zero = {}; return __zero; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txPrintf() implementation
//           Ðåàëèçàöèÿ txPrintf()
//=================================================================================================================

#if defined (_TX_CPP11)

template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                                  const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width,                   const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                precision_t prec, const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args);
                                         void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt);

template <typename T>                    void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int*     arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt);

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg, ArgsT... args)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*') {$ stream << std::setw (width); }
    else {$ TX_ERROR ("\"%%*\" required to setwidth (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '*') {$ stream << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%.*\" required to setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*' && fmt[2] == '.' && fmt[3] == '*') {$ stream << std::setw (width) << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%*.*\" required to setwidth (%d) and setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (!fmt[0]) {$}
    else {$ TX_ERROR ("No argument provided for %% in \"%s\" while printing \"%s\"", fmt, format); }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char*, int, const char*& fmt)
    {
$1  assert (&stream);
$   assert (fmt);

$   while (*fmt)
        {
        if (fmt[0] == '%')
            {
            if (fmt[1] == '%') fmt++;
            else break;
            }

        stream << *fmt++;
        }
$   }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg)
    {
$1  assert (&stream);
$   assert (fmt);

$   if (_TX_ARGUMENT_FAILED (&arg)) return;

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   fmt++;

$   char                    oldFill  = stream.fill (' ');
$   std::ios_base::fmtflags oldFlags = stream.flags();

$   for (;;) switch (*fmt)
        {
        case '-': $ stream << std::left;     fmt++; break;
        case '+': $ stream << std::showpos;  fmt++; break;
        case ' ': $ stream.fill (' ');       fmt++; break;
        case '#': $ stream << std::showbase; fmt++; break;
        case '0': $ stream.fill ('0');       fmt++; break;

        default:  $ goto end;
        }
    end:

$   int width = (*fmt != '*')?                  (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0);
$   int prec  = (*fmt == '.')? (*++fmt != '*')? (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0) : 0;

    if (width) {$ stream << std::setw (width);        }
    if (prec)  {$ stream << std::setprecision (prec); }

$   fmt += strspn (fmt, "hljztL");

$   switch (*fmt)
        {
        case '$':
        case '?': $                                              break;

        case 'd':
        case 'i':
        case 'u': $ stream << std::dec;                          break;

        case 'o': $ stream << std::oct;                          break;

        case 'x': $ stream << std::hex;                          break;
        case 'X': $ stream << std::hex        << std::uppercase; break;

        case 'f': $ stream << std::fixed;                        break;
        case 'F': $ stream << std::fixed      << std::uppercase; break;

        case 'e': $ stream << std::scientific;                   break;
        case 'E': $ stream << std::scientific << std::uppercase; break;

        case 'g': $                                              break;
        case 'G': $ stream                    << std::uppercase; break;

        case 'a': $                                              break;
        case 'A': $ stream                    << std::uppercase; break;

        case 'c':
        case 's':
        case 'p': $                                              break;

        default:  $ TX_ERROR ("Invalid format '%.1s' at \"%s\" while printing %s argument %d in \"%s\"", fmt, fmt, txTypename (arg), n, format); break;
        }

$   fmt++;

    if (&arg) {$ stream << arg;      }
    else      {$ stream << "(null)"; }

$   stream.fill  (oldFill);
$   stream.flags (oldFlags);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int* arg)
    {
$1  assert (fmt);

    if (_TX_ARGUMENT_FAILED (arg)) return;

    if (fmt[0] == '%' && fmt[1] == 'n') {$}
    else {$ TX_ERROR ("\"%%n\" required to store print length in int* argument %d in \"%s\"", n, format); }

$   *arg = (int) stream.str().length();

$   fmt += 2;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T> inline const T&    _txPrintfNormalizeArg (const T&           arg) { if (_TX_ARGUMENT_FAILED (&arg)) {;}          return arg;         }
                      inline const char* _txPrintfNormalizeArg (const std::string& arg) { if (_TX_ARGUMENT_FAILED (&arg)) return NULL; return arg.c_str(); }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (std::ostringstream& stream, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&stream)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   const char* fmt = format;
$   _txPrintF (stream, format, 2, fmt, _txPrintfNormalizeArg (args)...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (char buffer[], size_t size, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&buffer)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   if (size > 0) size--;
$   buffer[size] = 0;

$   if (!size) return 0;

$   std::ostringstream stream;
$   stream.rdbuf() -> pubsetbuf (buffer, size);

$   txPrintf (stream, format, args...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline std::string txFormat (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return "";

$   std::ostringstream stream;

$   txPrintf (stream, format, args...);

$   return stream.str();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   return printf ("%s", txFormat (format, args...) .c_str());
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

       int _txPrintfCheck (const char* format, ...) tx_printfy (1);
inline int _txPrintfCheck (const char*,        ...) { return 0; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txDialog methods implementation
//           Ðåàëèçàöèÿ ìåòîäîâ êëàññà txDialog
//
//           See [1] http://msdn.microsoft.com/ru-ru/library/windows/desktop/ms645389%28v=vs.85%29.aspx
//               [2] http://blogs.msdn.microsoft.com/oldnewthing/20050429-00/?p=35743
//               [3] http://blogs.msdn.microsoft.com/oldnewthing/20040623-00/?p=38753
//=================================================================================================================

txDialog::txDialog () :
    layout_ (NULL)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

txDialog::txDialog (const Layout* layout) :
    layout_ (layout)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

const txDialog::Layout* txDialog::setLayout (const Layout* layout)
    {
$1  assert (layout);

$   return ::std::swap (layout_, layout), layout;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (WORD resourceID)
    {
$1  const char* resName = (char*)(uintptr_t) resourceID;

$   if (!FindResource (NULL, resName, RT_DIALOG)) return TX_DEBUG_ERROR ("Íå íàéäåí ðåñóðñ äèàëîãà %d", resourceID), 0;

$   return DialogBoxParam (NULL, resName, NULL, (DLGPROC) DialogProc_, (LPARAM) this);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (const txDialog::Layout* layout /*= NULL*/, size_t bufsize /*= 0*/)
    {
$1  if (!layout)  layout = layout_;
$   if (!layout)  return TX_DEBUG_ERROR ("Íå óñòàíîâëåí äèíàìè÷åñêèé øàáëîí äèàëîãà"), 0;

$   if (!bufsize) bufsize = 1024;

$   DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$   if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà"), 0;

$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };

$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];

$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }

$   tmpl->cdit = (unsigned short) (i-1);

$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);

$   GlobalFree (tmpl);

$   return res;
    }

//-----------------------------------------------------------------------------------------------------------------

int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;

        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;

            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }

$   return FALSE;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;

$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;

$   WORD* pw = (WORD*) globalMem;

$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;

$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }

$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   return pw;
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;

$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;

$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;

$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }

$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }

$   *pw++ = 0;

$   return pw;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================

#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$

//}
//=================================================================================================================

//! @endcond

//=================================================================================================================
//{          Experimental Debugging macros
//! @name    Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//!          âî âðåìÿ åãî âûïîëíåíèÿ.
//!
//!          Ñäåëàé ïðèÿòíûìè òâîè <i>êðóãëûå ñóòêè 
    // AC_SRC_ALPHA.
    //
    // Åñëè â êàðòèíêå àëüôà-êàíàëà ôàêòè÷åñêè íåò, òî ÷åòâåðòûé ïàðàìåòð íàäî óñòàíîâèòü â 0.
    //
    //  êîäå íèæå ÷åòâåðòûé ïàðàìåòð îïðåäåëÿåòñÿ àâòîìàòè÷åñêè èç âûçîâà Win32::GetObject(), äëÿ óíèâåðñàëüíîñòè ïðèìåíåíèÿ
    // ôóíêöèè txAlphaBlend().
    //
    // Ïîæàëóéñòà, íå íàäî áåçäóìíî êîïèðîâàòü ñåáå â ïðîãðàììó ýòîò êîä. Îñìûñëèòå åãî, è ðåøèòå, áóäåòå ëè âû èñïîëüçîâàòü
    // àëüôà-êàíàë èëè íåò, è óñòàíîâèòå ÷åòâåðòûé ïàðàìåòð ñòðóêòóðû ëèáî AC_SRC_ALPHA, ëèáî 0. Èíà÷å ýòèì êîïèïàñòîì âû
    // ïîðîäèòå íåâíÿòíûé ïàëåíûé êîä è áåçíàäåæíî èñïîðòèòå ñåáå êàðìó. :((
    //
    // Íà äîëëàðû ($) íå îáðàùàéòå âíèìàíèÿ, îíè íóæíû äëÿ îòëàäêè áèáëèîòåêè TXLib. Â âàøåé ïðîãðàììå èõ èñïîëüçîâàòü íå íàäî.
    //
    //                       ____1____   2   ___________3___________     _______________________4________________________
    //                      /         \  |  /                       \   /                                                \.
 
$   BLENDFUNCTION blend = { AC_SRC_OVER, 0, (BYTE) ROUND (alpha * 255), (BYTE) ((bmap.bmBitsPixel == 32)? AC_SRC_ALPHA : 0) };
 
    //
    // * Âûçîâ ñòàíäàðòíîé ôóíêöèè Win32::AlphaBlend() *
    //
    // Íèæå - ýòî âûçîâ Win32::AlphaBlend(). Îí òàê óñòðîåí, ÷òî, åñëè âäðóã ÷òî-òî íå ïîëó÷èëîñü (ò.å. Win32::AlphaBlend()
    // âåðíåò 0), òî òîãäà áóäåò âûçâàíà Win32::BitBlt(), êîòîðàÿ ïðîñòî ñêîïèðóåò êàðòèíêó áåç ó÷åòà ïðîçðà÷íîñòè. Ïîãóãëèòå    // "Windows AlphaBlend function" è ïî÷èòàéòå ïðî åå ïàðàìåòðû.
    //
    // Êàê âèäèòå, îðèãèíàëüíàÿ ôóíêöèÿ èç Win32 ïðèíèìàåò ðàçìåðû íå òîëüêî èñõîäíîé, íî è èòîãîâîé êàðòèíêè, è åñëè îíè íå
    // ñîâïàäàþò, òî êàðòèíêà áóäåò óìåíüøåíà èëè óâåëè÷åíà. TXlib'îâñêàÿ <s>ïàëåíàÿ</s> ôóíêöèÿ txAlphaBlend ïðåäïîëàãàåò, ÷òî
    // ýòè ðàçìåðû âñåãäà ñîâïàäàþò, è ïîýòîìó ïðè ðàáîòå ñ txAlphaBlend() ìàñøòàá áóäåò âñåãäà 1:1. <s>Òàê ñåáå ðåøåíèå, íî</s>
    // ýòî ñäåëàíî äëÿ óïðîùåíèÿ âûçîâà ôóíêöèè txAlphaBlend().

$   if (Win32::AlphaBlend) // Òîëüêî òî, ÷òî ýòè ïàðàìåòðû ïåðåäàþòñÿ îäèíàêîâûìè, íå äàåò âîçìîæíîñòü ìåíÿòü ìàñøòàá êàðòèíêè!   // <<--
        {                  //                           //                                       vvvvv          vvvvvv            // <<--
$       ok &= txGDI (!!(Win32::AlphaBlend (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),          // <<==
                                           sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), blend)), // <<==
                                           destImage);  //                                       ^^^^^          ^^^^^^            // <<--
        }                  //                                                                    |||||          ||||||            // <<--
                           // Ñì. "AlphaBlend function" â Google, èùèòå ñìûñë ïàðàìåòðîâ wSrc è wDest (hSrc è hDest). Äóìàéòå!    // <<--

    else
        {
$       ok &= txGDI (!!(Win32::BitBlt     (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                           sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                           destImage);
$       ok = false;
        }

    //  ýòîé ôóíêöèè ïðîâåðîê è êîììåíòàðèåâ áîëüøå, ÷åì ðàáî÷åãî êîäà, è ýòî êàê áû íàìåêàåò, ÷òî íåòðóäíî ñäåëàòü ñâîþ
    // àíàëîãè÷íóþ ôóíêöèþ áåç îãðàíè÷åíèé ìàñøòàáà îòîáðàæåíèÿ. <s>Åñëè òû äî÷èòàë äî ýòîãî ìåñòà,</s> ïåðåñÿäü ñ èãëû TXLib'à
    // íà ïîâåðõíîñòü GDI Win32, <s>õîòÿ GDI òîæå òàê ñåáå, òàê ÷òî ëó÷øå çàþçàé GDI+, SFML, OpenGL èëè DirectX, áóäåò êðóòî.
    // Õîòÿ ýòî è ñëîæíåå.</s>

    // Íî ïîìíè ïðî ïàëåíûé êîïèïàñò è êàðìó, ñì. âûøå. ß ïðåäóïðåäèë.

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txAlphaBlend (double xDest, double yDest, HDC sourceImage,
                          double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txAlphaBlend (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, alpha);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txUseAlpha (HDC image)
    {
$1  if (_TX_HDC_FAILED (image)) return NULL;

$   HBITMAP bitmap = (HBITMAP) Win32::GetCurrentObject (image, OBJ_BITMAP);
$   if (!bitmap) return NULL;

$   DIBSECTION dib = {};
$   Win32::GetObject (bitmap, sizeof (dib), &dib) asserted;

$   POINT      size = {  dib.dsBm.bmWidth, dib.dsBm.bmHeight };
$   BITMAPINFO info = {{ sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB }};
$   RGBQUAD*   buf  = NULL;

$   bool isDIB = (dib.dsBm.bmPlanes        == 1                    &&
                  dib.dsBm.bmBitsPixel     == sizeof (RGBQUAD) * 8 &&
                  dib.dsBmih.biCompression == DIB_RGB_COLORS       &&
                  dib.dsBm.bmBits);
$   if (!isDIB)
        {
$       buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$       if (!buf) return NULL;

$       Win32::GetDIBits (image, bitmap, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;
        }
    else
        {
$       buf = (RGBQUAD*) dib.dsBm.bmBits;
        }

$   for (int y = 0; y < size.y; y++)
    for (int x = 0; x < size.x; x++)
        {
        RGBQUAD* color = &buf [x + y * size.x];  // Get color at (x, y) within image buffer

        color->rgbRed   = (BYTE) ROUND (color->rgbRed   * color->rgbReserved / 255.0);
        color->rgbGreen = (BYTE) ROUND (color->rgbGreen * color->rgbReserved / 255.0);
        color->rgbBlue  = (BYTE) ROUND (color->rgbBlue  * color->rgbReserved / 255.0);
        }

$   if (!isDIB)
        {
$       Win32::SetDIBitsToDevice (image, 0, 0, size.x, size.y, 0, 0, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;

$       delete[] buf;
        }

$   return image;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSaveImage (const char filename[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (filename)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))       return false;

$   POINT size = txGetExtent (dc);

$   size_t szHdrs = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER),
           szImg  = (size.x * size.y) * sizeof (RGBQUAD);

$   BITMAPFILEHEADER hdr  = { 0x4D42 /* 'MB' */, (DWORD) (szHdrs + szImg), 0, 0, (DWORD) szHdrs };
$   BITMAPINFOHEADER info = { sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB };

$   bool ok = true;

$   RGBQUAD* buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$   ok &= (buf != NULL);

$   if (ok) Win32::GetDIBits (dc, (HBITMAP) Win32::GetCurrentObject (dc, OBJ_BITMAP), 0, size.y,
                              buf, (BITMAPINFO*) &info, DIB_RGB_COLORS) asserted;
$   FILE* f = NULL;
$   if (ok) fopen_s (&f, filename, "wb");
$   ok &= (f != NULL);

$   if (ok) ok &= (fwrite (&hdr,  sizeof (hdr),  1, f) == 1);
$   if (ok) ok &= (fwrite (&info, sizeof (info), 1, f) == 1);
$   if (ok) ok &= (fwrite (buf,   szImg,         1, f) == 1);

$   ok &= (f && fclose (f) == 0);

$   delete[] buf;
$   buf = NULL;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline void txRedrawWindow()
    {
$1  txSleep (0);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txUpdateWindow (int update /*= true*/)
    {
$1  return _txCanvas_SetRefreshLock (update >= 0? !update : -update);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txBegin()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock + 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txEnd()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock - 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

double txSleep (double time)
    {
$1  LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   int lock = _txCanvas_RefreshLock;
$   _txCanvas_RefreshLock = 0;

$   HWND wnd = txWindow();
    if (wnd) {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   Sleep (ROUND ((time >= 0)? time : 0));

$   _txCanvas_RefreshLock = lock;

$   LARGE_INTEGER stop = {};
$   QueryPerformanceCounter (&stop) asserted;

$   return 1000.0 * (double) (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLock (bool wait /*= true*/)
    {
$0  if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);

$   if (wait) {$ return      EnterCriticalSection (&_txCanvas_LockBackBuf), true; }
    else      {$ return !!TryEnterCriticalSection (&_txCanvas_LockBackBuf);       }
    }

//-----------------------------------------------------------------------------------------------------------------

bool txUnlock()
    {
$0  LeaveCriticalSection (&_txCanvas_LockBackBuf);

$   if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T txUnlock (T value)
    {
$1  txUnlock();
$   return value;
    }

//-----------------------------------------------------------------------------------------------------------------

inline POINT txMousePos()
    {
$1  POINT pos = {};
$   GetCursorPos (&pos);

$   if (txWindow())
        {$ ScreenToClient (txWindow(), &pos); }

$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseX()
    {
    return txMousePos() .x;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseY()
    {
    return txMousePos() .y;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txMouseButtons()
    {
$1  return ((GetAsyncKeyState (VK_LBUTTON) & 0x8000) >> 15) |  // MSB to bit 0
           ((GetAsyncKeyState (VK_RBUTTON) & 0x8000) >> 14) |  // MSB to bit 1
           ((GetAsyncKeyState (VK_MBUTTON) & 0x8000) >> 13);   // MSB to bit 2
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetConsoleAttr (unsigned color /*= FOREGROUND_LIGHTGRAY*/)
    {
    unsigned oldAttr = txGetConsoleAttr();

    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), (WORD) color);

    return oldAttr;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txGetConsoleAttr()
    {
    CONSOLE_SCREEN_BUFFER_INFO con = {};
    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);

    return con.wAttributes;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txSetConsoleCursorPos (double x, double y)
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   COORD pos = { (short) ROUND (1.0 * x / fontSz.x + con.srWindow.Left),
                  (short) ROUND (1.0 * y / fontSz.y + con.srWindow.Top ) };

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos) asserted;

$   POINT prev = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return prev;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleCursorPos()
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  pos = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleExtent()
    {
$1  CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  size = { con.srWindow.Right  - con.srWindow.Left + 1,
                    con.srWindow.Bottom - con.srWindow.Top  + 1 };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClearConsole()
    {
$1  HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (out, &con) asserted;

$   COORD start = {con.srWindow.Left, con.srWindow.Top};

$   DWORD len   = (con.srWindow.Right  - con.srWindow.Left + 1) *
                  (con.srWindow.Bottom - con.srWindow.Top  + 1);

$   DWORD written = 0;
$   FillConsoleOutputCharacter (out, 0x20 /*' '*/,    len, start, &written) asserted;
$   FillConsoleOutputAttribute (out, con.wAttributes, len, start, &written) asserted;

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), start) asserted;

$   return written == len;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleFontSize()
    {
$1  Win32::CONSOLE_FONT_INFO font = {0, {8, 16}};

$   _TX_CALL (Win32::GetCurrentConsoleFont, (GetStdHandle (STD_OUTPUT_HANDLE), false, &font));

$   SIZE size = { font.dwFontSize.X, font.dwFontSize.Y };
$   txGDI (Win32::GetTextExtentPoint32 (_txCanvas_BackBuf[1], "W", 1, &size), txDC());

$   POINT sizeFont = { size.cx, size.cy };
$   return sizeFont;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextCursor (bool blink /*= true*/)
    {
$1  bool old = _txConsole_IsBlinking;

$   _txConsole_IsBlinking = blink;

$   return old;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPlaySound (const char filename[] /*= NULL*/, DWORD mode /*= SND_ASYNC*/)
    {
$1  mode |= SND_FILENAME | SND_NODEFAULT | SND_NOWAIT;
$   if (mode & SND_LOOP) mode = (mode & ~SND_SYNC) | SND_ASYNC;

$   if (!filename) mode = SND_PURGE;

$   return !!Win32::PlaySound (filename, NULL, mode);
    }

//-----------------------------------------------------------------------------------------------------------------

int txSpeak (const char* text, ...)
    {
$1  bool verbose = false; (void) verbose;
$   bool async   = false; (void) async;

$   for (; text && *text; text++)
        {
        if      (*text == '\a') {$ async   = true; }
        else if (*text == '\v') {$ verbose = true; }
        else break;
        }

$   char textA [_TX_BUFSIZE] = "You asked to speak empty text. I would rather say that TX Library is cool! Cats rules!";

$   va_list arg; va_start (arg, text);
    if (text && *text) {$ _tx_vsnprintf_s (textA, sizeof (textA) - 1, text, arg); }
$   va_end (arg);

#ifdef TX_USE_SPEAK

    if (text && verbose) {$ printf ("%s", textA); }

$   int time = GetTickCount();

$   static wchar_t textW [_TX_BUFSIZE * sizeof (wchar_t)] = L"";
$   MultiByteToWideChar (_TX_CODEPAGE, 0, textA, -1, textW, sizearr (textW));

$   static ISpVoice* voice = NULL;

$   if (text && !voice)
        {
$       HRESULT res = Win32::CoInitialize (NULL);
        if (res == S_OK) {$ Win32::CoCreateInstance (Win32::CLSID_SpVoice, NULL, CLSCTX_ALL, Win32::IID_ISpVoice, (void**) &voice); }
        }

$   if (text && voice)
        {
$       Win32::_fpreset();
$       voice->Speak (textW, SPF_PERSIST_XML | SPF_PURGEBEFORESPEAK | (async? SPF_ASYNC : 0), NULL);
$       tx_fpreset();
        }

$   if (!text && voice)
        {
$       voice->Release();
$       voice = NULL;

$       Win32::CoUninitialize();
        }

$   return (voice)? GetTickCount() - time : -1;

#else

$   if (text)
        {
$       unsigned oldAttr = txSetConsoleAttr (FOREGROUND_LIGHTRED | BACKGROUND_BLACK);

$       txNotifyIcon (NIIF_ERROR, "txSpeak(): Íå ìîãó ïðîèçíåñòè (íóæåí TX_USE_SPEAK, ñì. TXLib Help)", "\n" "%s", textA);

$       txSetConsoleAttr (oldAttr);
        }

$   return -1;

#endif
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txPlayVideo (int x, int y, int width, int height, const char fileName[],
                      double zoom /*= 0*/, double gain /*= 1*/, HWND wnd /*= txWindow()*/)
    {
$1  if (wnd && wnd == txWindow() && _TX_TXWINDOW_FAILED()) return -1;

$   int time = GetTickCount();

$   static char processUID [64] = "";
    if (!*processUID)
        {
$       FILETIME startTime = {}, null = {};
$       GetProcessTimes (GetCurrentProcess(), &startTime, &null, &null, &null) asserted;
$       _snprintf_s (processUID, sizeof (processUID) - 1, "TXLib[%08X%08X]::txPlayVideo",
                    (unsigned) startTime.dwHighDateTime, (unsigned) startTime.dwLowDateTime) < (int) sizeof (processUID) asserted;
        }

$   if (!fileName)
        {
$       txTaskKill ("vlc.exe", processUID, 0);  // Kill'em all, by command line pattern
$       return 0;
        }

$   static const char* vlcPath = _txPlayVideo_FindVLC();

$   if (!vlcPath || _access (vlcPath, 0) != 0)
        {
$       static int once = false;

$       if (*fileName && !once++)
            {$ txOutputDebugPrintf ("\a" "Íå íàéäåí âèäåîïðîèãðûâàòåëü VideoLAN (vlc.exe). Cêà÷àéòå åãî ñ ñàéòà VideoLAN.org "
                                    "è óñòàíîâèòå. Áåç óñòàíîâêè VideoLAN âèäåî âîñïðîèçâîäèòüñÿ íå áóäåò :(\n\n"
                                    "--\n" "Âñåãäà Âàøà, ôóíêöèÿ " /* êàê áû */ "txPlayVideo()...\n"
                                    "P.S. Ñì. ìîå îïèñàíèå â TXLib Help."); }
$       return INT_MIN;
        }

$   bool async = false;
    if (*fileName == '\a') {$ async = true; fileName++; }

$   RECT rect = {};
    if (wnd) {$ GetClientRect (wnd, &rect); }

    if (!width)  {$ width  = rect.right;  }
    if (!height) {$ height = rect.bottom; }

    // Create a child window to hold the video stream

$   const char* errPos = "ÂÍÅÇÀÏÍÎ";

$   volatile HWND child = NULL;
$   if (wnd && (wnd == txWindow()))
        {
$       const char* wndClass = txRegisterClass ("txPlayVideo", _txPlayVideo_WndProc, 0, NULL_BRUSH, 1);

$       static int number = 1;
$       CREATESTRUCT createData = { NULL, NULL, (HMENU) (size_t) number++, txWindow(), height, width, y, x,
                                    WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, __func__, wndClass };
$       child = txCreateExtraWindow (createData);
$       if (!child)
            {
$           txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                       strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå ìîãó ñîçäàòü îêíî äëÿ âèäåî :("), errPos));
$           return INT_MIN+3;
            }

$       BringWindowToTop (child);

$       wnd = child;
        }

    // Build the command line

    if (!zoom && !wnd) {$ zoom = 1; }

$   char sZoom [64] = "--autoscale";
    if (zoom) {$ _snprintf_s (sZoom, sizeof (sZoom) - 1, "--no-autoscale --zoom=%.10g", zoom) < (int) sizeof (sZoom) asserted; }

$   static char cmd [MAX_PATH*2 + 1024] = "";

$   _snprintf_s (cmd, sizeof (cmd) - 1, "\"%s\" \"%s\" vlc://quit"

                 " %s --gain=%.10g --drawable-hwnd=%" PRIu64 " --video-title=\"%s\" --logfile=%s"

                 " --live-caching=500 --network-caching=500 --quiet-synchro --no-embedded-video --file-logging"

                 " --ignore-config --reset-config --no-one-instance --play-and-exit"
                 " --intf=dummy --dummy-quiet --quiet --no-video-deco --no-video-title-show --no-stats --no-sub-autodetect-file"
                 " --no-disable-screensaver --no-snapshot-preview --no-auto-preparse --no-mouse-events --no-keyboard-events",

                 vlcPath, (*fileName? fileName : "fileName"), sZoom, gain, (uint64_t) wnd, processUID, _txLogName) < (int) sizeof (cmd) asserted;

$   txOutputDebugPrintf ("txPlayVideo (%d, %d, %d, %d, \"%s\", %lg, %lg, %p): [%s]\n\n",
                         x, y, width, height, fileName, zoom, gain, wnd, cmd);
$   if (!*fileName)
        {
        if (child) {$ txDestroyWindow (child); }
$       return (intptr_t) cmd;
        }

$   if (!strstr (fileName, "://") && _access (fileName, 0) != 0)
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå íàéäåí ôàéë \"%s\"", fileName), errPos));

        if (child) {$ txDestroyWindow (child); }
$       return INT_MIN+1;
        }

    // Run VLC, run

$   PROCESS_INFORMATION vlc   = {};
$   STARTUPINFO         start = { sizeof (start) };
$   DWORD               ret   = 0;

$   if (CreateProcess (NULL, cmd, NULL, NULL, true, 0, NULL, NULL, &start, &vlc) &&
        vlc.hProcess && vlc.hThread)
        {
$       if (child)
            {
$           assert (wnd == child);
$           SetWindowLongPtr (wnd, GWLP_USERDATA, (LONG_PTR) vlc.hProcess);
            }

$       if (!async)
            {
$           WaitForSingleObject (vlc.hProcess, INFINITE);
$           GetExitCodeProcess  (vlc.hProcess, &ret) asserted;
            }

$       if (!child)
            {
$           CloseHandle (vlc.hProcess) asserted;
            }

$       CloseHandle (vlc.hThread) asserted;

$       return (async? (intptr_t) wnd : (ret == 0)? time - GetTickCount() : - (int) ret);
        }
    else
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Îøèáêà çàïóñêà VideoLAN (%s)", cmd), errPos));
$       if (child)
            {$ txDestroyWindow (child); }

$       return INT_MIN+4;
        }

    #undef PROCESS_UID_
    }

//-----------------------------------------------------------------------------------------------------------------

inline intptr_t txPlayVideo (const char fileName[], double zoom /*= 0*/, double gain /*= 0*/, HWND wnd /*= txWindow()*/)
    {
$1  return txPlayVideo (0, 0, 0, 0, fileName, zoom, gain, wnd);
    }

//-----------------------------------------------------------------------------------------------------------------

LRESULT CALLBACK _txPlayVideo_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
    const UINT_PTR checkTimer = 1;

    switch (msg)
        {
        case WM_CREATE:
            {
$1          SetTimer  (wnd, checkTimer, 5*_txWindowUpdateInterval, NULL) asserted;
            }
            break;

        case WM_DESTROY:
            {
$1          KillTimer (wnd, checkTimer) asserted;

$           HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

$           if (vlc)
                {
$               Win32::TerminateProcess (vlc, 0);

$               CloseHandle (vlc) asserted;

$               SetWindowLongPtr (wnd, GWLP_USERDATA, 0);
                }
            }
            break;

        case WM_TIMER:
            {
            HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

            if (vlc && WaitForSingleObject (vlc, 0) != WAIT_TIMEOUT)
                {
$1              DestroyWindow (wnd) asserted;
                }
            }
            break;

        default:
            break;
        }

    return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txPlayVideo_FindVLC()
    {
$1  static char vlcPath [MAX_PATH] = "";

$   if (SearchPath (NULL, "vlc.bat", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (SearchPath (NULL, "vlc.exe", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", NULL, vlcPath, sizeof (vlcPath)))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", "InstallDir", vlcPath, sizeof (vlcPath)))
        {
$       strncat_s (vlcPath, sizeof (vlcPath) - 1, "\\vlc.exe", INT_MAX);

        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files"    "\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   return NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// +--<<< Ýòî âðÿä ëè èìååò îòíîøåíèå ê òîìó, ÷òî âû èùåòå :)
// V      Ïîëåçíî ñìîòðåòü íå òîëüêî ââåðõ, íî è âíèç

WNDPROC txSetWindowsHook (WNDPROC wndProc /*= NULL*/)
    {
$1  WNDPROC old = _txAltWndProc; _txAltWndProc = wndProc;
$   return  old;
    }

//-----------------------------------------------------------------------------------------------------------------

//     +--<<< À ýòî, íàêîíåö, èñêîìîå îïðåäåëåíèå ýòîé ôóíêöèè.
//     |      Ñìîòðèòå ïî ñòîðîíàì! Íóæíàÿ âàì ôóíêöèÿ ãäå-òî ðÿäîì.
//     |
//     v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()
    {
    txMessageBox ("Ýòî çàïëàíèðîâàííàÿ îøèáêà. Òàêîå áûâàåò. Âû õîòåëè âûçâàòü:\n\n"

                  "txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()\n\n"

                  "Õîòü âû äîëãî [êîïèðîâàëè]íàáèðàëè ýòî èìÿ, íà ñàìîì äåëå ýòà ôóíêöèÿ íå ðåàëèçîâàíà. "
                  "Åñòü äðóãàÿ ôóíêöèÿ, êîòîðàÿ óáèðàåò àâòî-ïàóçó â êîíöå ïðîãðàììû, íî â õåëïå ïðî íåå íå íàïèñàíî.\n\n"

                  "Íî íå âñå òàê ïëîõî. Îïðåäåëåíèå íóæíîé ôóíêöèè åñòü â èñõîäíûõ òåêñòàõ TXLib.h, îíî ëåæèò ðÿäîì "
                  "ñ îïðåäåëåíèåì òîé ôóíêöèè ñ äëèííûì íàçâàíèåì, êîòîðóþ âû ñåé÷àñ âûçâàëè.\n\n"

                  "Íàæìèòå â ðåäàêòîðå Ctrl+O, íàéäèòå è îòêðîéòå ôàéë TXLib.h (îí ëåæèò â ïàïêå, êóäà âû "
                  "óñòàíîâèëè TXLib), çàòåì íàæìèòå Ctrl+F è èùèòå \"txIDontWant\". Óäà÷è!\n\n",

                  "Íå ïîëó÷èëîñü", MB_ICONSTOP);

    // The truth is out there... (C++files)

    return false;
    }

//-----------------------------------------------------------------------------------------------------------------

// Bingo! Now you are learned to use the Sources, Luke. And may the Source be with you.

inline bool txDisableAutoPause()
    {
    _txExit = true;
    return true;
    }

// P.S. This library contains more undocumented functions. Search them via "Luke" keyword.

//-----------------------------------------------------------------------------------------------------------------

void _txDump (const void* address, const char name[] /*= "_txDump()"*/, bool pause /*= true*/)
    {
$1  assert (!_txIsBadReadPtr (address));

    const unsigned char* p = (const unsigned char*) address;
$   unsigned x = 0;

$   unsigned attr = txGetConsoleAttr();

$   txSetConsoleAttr (FOREGROUND_WHITE);
$   printf ("\n%*.*s ", (int) sizeof (address) * 2, (int) sizeof (address) * 2, ((name)? name : ""));

$   txSetConsoleAttr (FOREGROUND_YELLOW);
$   for (x = 0; x < 16; x++) printf ("%02X ", x);
$   for (x = 0; x < 16; x++) printf ("%X",    x);

$   const char   isCtrl[] = "\a" "\b" "\n" "\r" "\t" "\0";
$   const char   xlatCh[] =  "·"  "·"  "·"  "·"  "·"  "·";
$   const size_t szCtrl   = sizeof (isCtrl) - 1;

$   int oldCP = GetConsoleOutputCP();

$   for (int y = 0; y < 16; y++, p += 16)
        {
        txSetConsoleAttr (FOREGROUND_YELLOW);

        printf ("\n" "%*p ", (int) sizeof (address) * 2, p);

        int color = FOREGROUND_LIGHTGREEN;

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);
            printf ("%02X ", p[x]);
            }

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);

            char c = p[x];
            const char* ctrl = (const char*) memchr (isCtrl, c, szCtrl);
            if (ctrl) c = xlatCh [ctrl - isCtrl];

            if (ctrl) SetConsoleOutputCP (1251);

            printf ("%c", c);

            if (ctrl) SetConsoleOutputCP (oldCP);
            }
        }

$   txSetConsoleAttr (attr);
$   printf ("\n");

$   if (pause)
        {
$       SetConsoleOutputCP (_TX_CODEPAGE);

$       fprintf (stderr, "[Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]                          CodePage = %5d\n", oldCP);
$       (void)_getch();

$       SetConsoleOutputCP (oldCP);
        }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txStackBackTrace (const char file[] /*= "?"*/, int line /*= 0*/, const char func[] /*= "?"*/,
                        bool readSource /*= true*/)
    {
$1  unsigned attr = txGetConsoleAttr();
$   txSetConsoleAttr (FOREGROUND_LIGHTCYAN);

$   fprintf (stderr, "\n" "--------------------------------------------------\n"
                          "Òðàññèðîâêà ñòåêà èç \"%s\" at %s (%d):\n\n"
                          "%s\n\n"
                          "--------------------------------------------------\n\n",
                          func, file, line, _txCaptureStackBackTrace (1, readSource));

$   txSetConsoleAttr (attr);
    }

//-----------------------------------------------------------------------------------------------------------------

char* txDemangle (const char* mangledName, std::nomeow_t)
    {
$1  if (!mangledName) return NULL;

$   char* typeName = NULL;

    #if defined (_GCC_VER)

$   int err = 1;
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err); (void) err;
    if (typeName) {$ return typeName; }

    #endif

$   unsigned short flags = 0;

$   if (mangledName[0] == '.')
        {
$       mangledName++;
$       flags = 0x2800;  // UNDNAME_32_BIT_DECODE | UNDNAME_TYPE_ONLY
        }

$   typeName = _TX_CALL (Win32::__unDName, (NULL, mangledName, 0, malloc, free, flags));
    if (typeName) {$ return typeName; }

$   return _strdup (mangledName);
    }

//-----------------------------------------------------------------------------------------------------------------

std::string txDemangle (const char* mangledName)
    {
$1  char* typeName = txDemangle (mangledName, std::nomeow);
$   std::string name (typeName? typeName : "");
$   free (typeName);

$   return name;
    }

//-----------------------------------------------------------------------------------------------------------------

double txQueryPerformance()
    {
$1  int maxTime    =  500;
$   int maxSamples =  100;
$   POINT size     = {100, 100};

$   HDC dc = _txBuffer_Create (txWindow(), &size, NULL);
$   assert (dc); if (!dc) return -1;

$   DWORD mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), 1);
$   assert (mask);

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   int samples = 0;
$   while (samples++ < maxSamples)
        {
$       LARGE_INTEGER cur = {};
$       QueryPerformanceCounter (&cur) asserted;

$       double t = 1000.0 * (double) (cur.QuadPart - start.QuadPart) / (double) freq.QuadPart;
$       if (t > maxTime) break;

        // Draw test scene

$       for (int y = 0; y < size.y; y++)
        for (int x = 0; x < size.x; x++)     txSetPixel (x, y, TX_BLACK, dc);

$       for (int y = 0; y < size.y; y += 10)
        for (int x = 0; x < size.x; x += 50) txTextOut  (x, y, "*", dc);

$       txEllipse (0, 0, size.x, size.y, dc);
$       txFloodFill (size.x/2, size.y/2, TX_TRANSPARENT, FLOODFILLSURFACE, dc);

$       txBitBlt (dc, size.x/2,        0, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc,        0, size.y/2) asserted;
$       txBitBlt (dc,        0, size.y/2, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, size.x/2,        0) asserted;
        }

$   mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), mask);
$   assert (mask);

$   _txBuffer_Delete (&dc);

$   return 3.0 * samples / sqrt (1.0 * size.x * size.y);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_TX_CPP11)
template <int txFramesToAverage>
#endif

double txGetFPS (int minFrames)
    {
$1  static LARGE_INTEGER time0 = {}; if (!time0.QuadPart) QueryPerformanceCounter (&time0);
$          LARGE_INTEGER time  = {};                      QueryPerformanceCounter (&time);

$   if (time.QuadPart - time0.QuadPart == 0)
        {$ return 0; }

$   LARGE_INTEGER freq = {}; QueryPerformanceFrequency (&freq);

$   double fps = (double) freq.QuadPart / (double) (time.QuadPart - time0.QuadPart);
$   time0 = time;

$   if (txFramesToAverage == 0) return fps;

$   static double average [txFramesToAverage] = {};
$   static unsigned n = 0;

$   average [n++ % txFramesToAverage] = fps;

$   unsigned nn = MIN (n, (unsigned) sizearr (average));

$   static double median  [txFramesToAverage] = {};
$   std::copy (average, average + nn, median);
$   std::nth_element (median, median + nn/2, median + nn);

$   fps = (median [(nn-1) / 2] + median [nn / 2]) / 2.0;

$   return ((int)n >= MIN (minFrames, txFramesToAverage))? fps : 0;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txExtractColor (COLORREF color, COLORREF component)
    {
$1  switch (component)
        {
        case TX_RED:
        case TX_HUE:        $ return (color >>  0) & 0xFF;

        case TX_GREEN:
        case TX_SATURATION: $ return (color >>  8) & 0xFF;

        case TX_BLUE:
        case TX_LIGHTNESS:  $ return (color >> 16) & 0xFF;

        default:            $ return CLR_INVALID;
        }
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txRGB2HSL (COLORREF rgbColor)
    {
$1  int r = (int) txExtractColor (rgbColor, TX_RED),
        g = (int) txExtractColor (rgbColor, TX_GREEN),
        b = (int) txExtractColor (rgbColor, TX_BLUE);

$   double m1 = MAX (MAX (r, g), b) / 255.0,
           m2 = MIN (MIN (r, g), b) / 255.0,
           dm = m1 - m2,
           sm = m1 + m2,

           ir = r / 255.0,
           ig = g / 255.0,
           ib = b / 255.0,

           ih = 0,
           is = 0,
           il = sm / 2;

$   const double prec = 0.001;

$   if (fabs (dm) < prec)
        {
$       is = dm / ((sm <= 1)? sm : (2-sm));

$       double cr = (m1 - ir) / dm,
               cg = (m1 - ig) / dm,
               cb = (m1 - ib) / dm;

$       if (fabs (ir - m1) < prec) ih =     cb - cg;
$       if (fabs (ig - m1) < prec) ih = 2 + cr - cb;
$       if (fabs (ib - m1) < prec) ih = 4 + cg - cr;
        }

$   ih = (ih >= 0)? ih*60 : ih*60 + 360;

$   return RGB (ROUND (ih / 360 * 255), ROUND (is * 255), ROUND (il * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txHSL2RGB (COLORREF hslColor)
    {
$1  struct xRGB
        {
        static double calc (double h, double m1, double m2)
            {
$           if (h < 0)   h += 360;
$           if (h > 360) h -= 360;

$           return (h <  60)? m1 + (m2-m1) *      h  / 60 :
                   (h < 180)? m2 :
                   (h < 240)? m1 + (m2-m1) * (240-h) / 60 :
                              m1;
            }
        };

$   int h = (int) txExtractColor (hslColor, TX_HUE),
        s = (int) txExtractColor (hslColor, TX_SATURATION),
        l = (int) txExtractColor (hslColor, TX_LIGHTNESS);

$   double ih = h / 255.0 * 360.0,
           il = l / 100.0,
           is = s / 100.0,

           m2 = (il <= 0.5)? il * (1 + is) : il + is - il * is,
           m1 = 2 * il - m2,

           ir = s? xRGB::calc (ih + 120, m1, m2) : il,
           ig = s? xRGB::calc (ih,       m1, m2) : il,
           ib = s? xRGB::calc (ih - 120, m1, m2) : il;

$   return RGB (ROUND (ir * 255), ROUND (ig * 255), ROUND (ib * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (std::nomeow_t, double left, double right)
    {
    return left + (right - left) * ((double) rand() / RAND_MAX);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (std::nomeow_t, Tx x, Ta a, Tb b)
    {
    return a <= x && x <= b;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int random (int range)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return rand() % range;
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (double left, double right)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return random (std::nomeow, left, right);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (Tx x, Ta a, Tb b)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return In (std::nomeow, x, a, b);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const POINT& pt, const RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.x, rect.left, rect.right) &&
           In (std::nomeow, pt.y, rect.top,  rect.bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const COORD& pt, const SMALL_RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.X, rect.Left, rect.Right) &&
           In (std::nomeow, pt.Y, rect.Top,  rect.Bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

void tx_fpreset()
    {
$1  txAutoLock _lock;

$   Win32::_fpreset();

$   unsigned new87 = 0x0008001C;  // _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW

    #if !defined (__CYGWIN__)

$   unsigned old87 = 0;
$   if (_controlfp_s (&old87, 0, 0) == 0)
        {$ (void) _controlfp_s (&old87, old87  & ~new87, 0x0008001F); }  // _MCW_EM

    #else

$   Win32::_controlfp (Win32::_controlfp (0, 0) & ~new87, 0x0008001F);    // _MCW_EM

    #endif
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T zero() { T __zero = {}; return __zero; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txPrintf() implementation
//           Ðåàëèçàöèÿ txPrintf()
//=================================================================================================================

#if defined (_TX_CPP11)

template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                                  const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width,                   const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                precision_t prec, const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args);
                                         void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt);

template <typename T>                    void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int*     arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt);

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg, ArgsT... args)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*') {$ stream << std::setw (width); }
    else {$ TX_ERROR ("\"%%*\" required to setwidth (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '*') {$ stream << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%.*\" required to setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*' && fmt[2] == '.' && fmt[3] == '*') {$ stream << std::setw (width) << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%*.*\" required to setwidth (%d) and setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (!fmt[0]) {$}
    else {$ TX_ERROR ("No argument provided for %% in \"%s\" while printing \"%s\"", fmt, format); }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char*, int, const char*& fmt)
    {
$1  assert (&stream);
$   assert (fmt);

$   while (*fmt)
        {
        if (fmt[0] == '%')
            {
            if (fmt[1] == '%') fmt++;
            else break;
            }

        stream << *fmt++;
        }
$   }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg)
    {
$1  assert (&stream);
$   assert (fmt);

$   if (_TX_ARGUMENT_FAILED (&arg)) return;

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   fmt++;

$   char                    oldFill  = stream.fill (' ');
$   std::ios_base::fmtflags oldFlags = stream.flags();

$   for (;;) switch (*fmt)
        {
        case '-': $ stream << std::left;     fmt++; break;
        case '+': $ stream << std::showpos;  fmt++; break;
        case ' ': $ stream.fill (' ');       fmt++; break;
        case '#': $ stream << std::showbase; fmt++; break;
        case '0': $ stream.fill ('0');       fmt++; break;

        default:  $ goto end;
        }
    end:

$   int width = (*fmt != '*')?                  (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0);
$   int prec  = (*fmt == '.')? (*++fmt != '*')? (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0) : 0;

    if (width) {$ stream << std::setw (width);        }
    if (prec)  {$ stream << std::setprecision (prec); }

$   fmt += strspn (fmt, "hljztL");

$   switch (*fmt)
        {
        case '$':
        case '?': $                                              break;

        case 'd':
        case 'i':
        case 'u': $ stream << std::dec;                          break;

        case 'o': $ stream << std::oct;                          break;

        case 'x': $ stream << std::hex;                          break;
        case 'X': $ stream << std::hex        << std::uppercase; break;

        case 'f': $ stream << std::fixed;                        break;
        case 'F': $ stream << std::fixed      << std::uppercase; break;

        case 'e': $ stream << std::scientific;                   break;
        case 'E': $ stream << std::scientific << std::uppercase; break;

        case 'g': $                                              break;
        case 'G': $ stream                    << std::uppercase; break;

        case 'a': $                                              break;
        case 'A': $ stream                    << std::uppercase; break;

        case 'c':
        case 's':
        case 'p': $                                              break;

        default:  $ TX_ERROR ("Invalid format '%.1s' at \"%s\" while printing %s argument %d in \"%s\"", fmt, fmt, txTypename (arg), n, format); break;
        }

$   fmt++;

    if (&arg) {$ stream << arg;      }
    else      {$ stream << "(null)"; }

$   stream.fill  (oldFill);
$   stream.flags (oldFlags);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int* arg)
    {
$1  assert (fmt);

    if (_TX_ARGUMENT_FAILED (arg)) return;

    if (fmt[0] == '%' && fmt[1] == 'n') {$}
    else {$ TX_ERROR ("\"%%n\" required to store print length in int* argument %d in \"%s\"", n, format); }

$   *arg = (int) stream.str().length();

$   fmt += 2;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T> inline const T&    _txPrintfNormalizeArg (const T&           arg) { if (_TX_ARGUMENT_FAILED (&arg)) {;}          return arg;         }
                      inline const char* _txPrintfNormalizeArg (const std::string& arg) { if (_TX_ARGUMENT_FAILED (&arg)) return NULL; return arg.c_str(); }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (std::ostringstream& stream, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&stream)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   const char* fmt = format;
$   _txPrintF (stream, format, 2, fmt, _txPrintfNormalizeArg (args)...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (char buffer[], size_t size, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&buffer)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   if (size > 0) size--;
$   buffer[size] = 0;

$   if (!size) return 0;

$   std::ostringstream stream;
$   stream.rdbuf() -> pubsetbuf (buffer, size);

$   txPrintf (stream, format, args...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline std::string txFormat (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return "";

$   std::ostringstream stream;

$   txPrintf (stream, format, args...);

$   return stream.str();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   return printf ("%s", txFormat (format, args...) .c_str());
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

       int _txPrintfCheck (const char* format, ...) tx_printfy (1);
inline int _txPrintfCheck (const char*,        ...) { return 0; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txDialog methods implementation
//           Ðåàëèçàöèÿ ìåòîäîâ êëàññà txDialog
//
//           See [1] http://msdn.microsoft.com/ru-ru/library/windows/desktop/ms645389%28v=vs.85%29.aspx
//               [2] http://blogs.msdn.microsoft.com/oldnewthing/20050429-00/?p=35743
//               [3] http://blogs.msdn.microsoft.com/oldnewthing/20040623-00/?p=38753
//=================================================================================================================

txDialog::txDialog () :
    layout_ (NULL)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

txDialog::txDialog (const Layout* layout) :
    layout_ (layout)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

const txDialog::Layout* txDialog::setLayout (const Layout* layout)
    {
$1  assert (layout);

$   return ::std::swap (layout_, layout), layout;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (WORD resourceID)
    {
$1  const char* resName = (char*)(uintptr_t) resourceID;

$   if (!FindResource (NULL, resName, RT_DIALOG)) return TX_DEBUG_ERROR ("Íå íàéäåí ðåñóðñ äèàëîãà %d", resourceID), 0;

$   return DialogBoxParam (NULL, resName, NULL, (DLGPROC) DialogProc_, (LPARAM) this);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (const txDialog::Layout* layout /*= NULL*/, size_t bufsize /*= 0*/)
    {
$1  if (!layout)  layout = layout_;
$   if (!layout)  return TX_DEBUG_ERROR ("Íå óñòàíîâëåí äèíàìè÷åñêèé øàáëîí äèàëîãà"), 0;

$   if (!bufsize) bufsize = 1024;

$   DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$   if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà"), 0;

$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };

$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];

$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }

$   tmpl->cdit = (unsigned short) (i-1);

$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);

$   GlobalFree (tmpl);

$   return res;
    }

//-----------------------------------------------------------------------------------------------------------------

int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;

        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;

            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }

$   return FALSE;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;

$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;

$   WORD* pw = (WORD*) globalMem;

$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;

$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }

$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   return pw;
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;

$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;

$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;

$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }

$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }

$   *pw++ = 0;

$   return pw;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================

#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$

//}
//=================================================================================================================

//! @endcond

//=================================================================================================================
//{          Experimental Debugging macros
//! @name    Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//!          âî âðåìÿ åãî âûïîëíåíèÿ.
//!
//!          Ñäåëàé ïðèÿòíûìè òâîè <i>êðóãëûå ñóòêè 
    // "Windows AlphaBlend function" è ïî÷èòàéòå ïðî åå ïàðàìåòðû.
    //
    // Êàê âèäèòå, îðèãèíàëüíàÿ ôóíêöèÿ èç Win32 ïðèíèìàåò ðàçìåðû íå òîëüêî èñõîäíîé, íî è èòîãîâîé êàðòèíêè, è åñëè îíè íå
    // ñîâïàäàþò, òî êàðòèíêà áóäåò óìåíüøåíà èëè óâåëè÷åíà. TXlib'îâñêàÿ <s>ïàëåíàÿ</s> ôóíêöèÿ txAlphaBlend ïðåäïîëàãàåò, ÷òî    // ýòè ðàçìåðû âñåãäà ñîâïàäàþò, è ïîýòîìó ïðè ðàáîòå ñ txAlphaBlend() ìàñøòàá áóäåò âñåãäà 1:1. <s>Òàê ñåáå ðåøåíèå, íî</s>
    // ýòî ñäåëàíî äëÿ óïðîùåíèÿ âûçîâà ôóíêöèè txAlphaBlend().

$   if (Win32::AlphaBlend) // Òîëüêî òî, ÷òî ýòè ïàðàìåòðû ïåðåäàþòñÿ îäèíàêîâûìè, íå äàåò âîçìîæíîñòü ìåíÿòü ìàñøòàá êàðòèíêè!   // <<--
        {                  //                           //                                       vvvvv          vvvvvv            // <<--
$       ok &= txGDI (!!(Win32::AlphaBlend (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),          // <<==
                                           sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), blend)), // <<==
                                           destImage);  //                                       ^^^^^          ^^^^^^            // <<--
        }                  //                                                                    |||||          ||||||            // <<--
                           // Ñì. "AlphaBlend function" â Google, èùèòå ñìûñë ïàðàìåòðîâ wSrc è wDest (hSrc è hDest). Äóìàéòå!    // <<--

    else
        {
$       ok &= txGDI (!!(Win32::BitBlt     (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                           sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                           destImage);
$       ok = false;
        }

    //  ýòîé ôóíêöèè ïðîâåðîê è êîììåíòàðèåâ áîëüøå, ÷åì ðàáî÷åãî êîäà, è ýòî êàê áû íàìåêàåò, ÷òî íåòðóäíî ñäåëàòü ñâîþ
    // àíàëîãè÷íóþ ôóíêöèþ áåç îãðàíè÷åíèé ìàñøòàáà îòîáðàæåíèÿ. <s>Åñëè òû äî÷èòàë äî ýòîãî ìåñòà,</s> ïåðåñÿäü ñ èãëû TXLib'à
    // íà ïîâåðõíîñòü GDI Win32, <s>õîòÿ GDI òîæå òàê ñåáå, òàê ÷òî ëó÷øå çàþçàé GDI+, SFML, OpenGL èëè DirectX, áóäåò êðóòî.
    // Õîòÿ ýòî è ñëîæíåå.</s>

    // Íî ïîìíè ïðî ïàëåíûé êîïèïàñò è êàðìó, ñì. âûøå. ß ïðåäóïðåäèë.

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txAlphaBlend (double xDest, double yDest, HDC sourceImage,
                          double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txAlphaBlend (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, alpha);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txUseAlpha (HDC image)
    {
$1  if (_TX_HDC_FAILED (image)) return NULL;

$   HBITMAP bitmap = (HBITMAP) Win32::GetCurrentObject (image, OBJ_BITMAP);
$   if (!bitmap) return NULL;

$   DIBSECTION dib = {};
$   Win32::GetObject (bitmap, sizeof (dib), &dib) asserted;

$   POINT      size = {  dib.dsBm.bmWidth, dib.dsBm.bmHeight };
$   BITMAPINFO info = {{ sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB }};
$   RGBQUAD*   buf  = NULL;

$   bool isDIB = (dib.dsBm.bmPlanes        == 1                    &&
                  dib.dsBm.bmBitsPixel     == sizeof (RGBQUAD) * 8 &&
                  dib.dsBmih.biCompression == DIB_RGB_COLORS       &&
                  dib.dsBm.bmBits);
$   if (!isDIB)
        {
$       buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$       if (!buf) return NULL;

$       Win32::GetDIBits (image, bitmap, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;
        }
    else
        {
$       buf = (RGBQUAD*) dib.dsBm.bmBits;
        }

$   for (int y = 0; y < size.y; y++)
    for (int x = 0; x < size.x; x++)
        {
        RGBQUAD* color = &buf [x + y * size.x];  // Get color at (x, y) within image buffer

        color->rgbRed   = (BYTE) ROUND (color->rgbRed   * color->rgbReserved / 255.0);
        color->rgbGreen = (BYTE) ROUND (color->rgbGreen * color->rgbReserved / 255.0);
        color->rgbBlue  = (BYTE) ROUND (color->rgbBlue  * color->rgbReserved / 255.0);
        }

$   if (!isDIB)
        {
$       Win32::SetDIBitsToDevice (image, 0, 0, size.x, size.y, 0, 0, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;

$       delete[] buf;
        }

$   return image;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSaveImage (const char filename[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (filename)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))       return false;

$   POINT size = txGetExtent (dc);

$   size_t szHdrs = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER),
           szImg  = (size.x * size.y) * sizeof (RGBQUAD);

$   BITMAPFILEHEADER hdr  = { 0x4D42 /* 'MB' */, (DWORD) (szHdrs + szImg), 0, 0, (DWORD) szHdrs };
$   BITMAPINFOHEADER info = { sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB };

$   bool ok = true;

$   RGBQUAD* buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$   ok &= (buf != NULL);

$   if (ok) Win32::GetDIBits (dc, (HBITMAP) Win32::GetCurrentObject (dc, OBJ_BITMAP), 0, size.y,
                              buf, (BITMAPINFO*) &info, DIB_RGB_COLORS) asserted;
$   FILE* f = NULL;
$   if (ok) fopen_s (&f, filename, "wb");
$   ok &= (f != NULL);

$   if (ok) ok &= (fwrite (&hdr,  sizeof (hdr),  1, f) == 1);
$   if (ok) ok &= (fwrite (&info, sizeof (info), 1, f) == 1);
$   if (ok) ok &= (fwrite (buf,   szImg,         1, f) == 1);

$   ok &= (f && fclose (f) == 0);

$   delete[] buf;
$   buf = NULL;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline void txRedrawWindow()
    {
$1  txSleep (0);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txUpdateWindow (int update /*= true*/)
    {
$1  return _txCanvas_SetRefreshLock (update >= 0? !update : -update);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txBegin()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock + 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txEnd()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock - 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

double txSleep (double time)
    {
$1  LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   int lock = _txCanvas_RefreshLock;
$   _txCanvas_RefreshLock = 0;

$   HWND wnd = txWindow();
    if (wnd) {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   Sleep (ROUND ((time >= 0)? time : 0));

$   _txCanvas_RefreshLock = lock;

$   LARGE_INTEGER stop = {};
$   QueryPerformanceCounter (&stop) asserted;

$   return 1000.0 * (double) (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLock (bool wait /*= true*/)
    {
$0  if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);

$   if (wait) {$ return      EnterCriticalSection (&_txCanvas_LockBackBuf), true; }
    else      {$ return !!TryEnterCriticalSection (&_txCanvas_LockBackBuf);       }
    }

//-----------------------------------------------------------------------------------------------------------------

bool txUnlock()
    {
$0  LeaveCriticalSection (&_txCanvas_LockBackBuf);

$   if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T txUnlock (T value)
    {
$1  txUnlock();
$   return value;
    }

//-----------------------------------------------------------------------------------------------------------------

inline POINT txMousePos()
    {
$1  POINT pos = {};
$   GetCursorPos (&pos);

$   if (txWindow())
        {$ ScreenToClient (txWindow(), &pos); }

$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseX()
    {
    return txMousePos() .x;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseY()
    {
    return txMousePos() .y;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txMouseButtons()
    {
$1  return ((GetAsyncKeyState (VK_LBUTTON) & 0x8000) >> 15) |  // MSB to bit 0
           ((GetAsyncKeyState (VK_RBUTTON) & 0x8000) >> 14) |  // MSB to bit 1
           ((GetAsyncKeyState (VK_MBUTTON) & 0x8000) >> 13);   // MSB to bit 2
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetConsoleAttr (unsigned color /*= FOREGROUND_LIGHTGRAY*/)
    {
    unsigned oldAttr = txGetConsoleAttr();

    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), (WORD) color);

    return oldAttr;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txGetConsoleAttr()
    {
    CONSOLE_SCREEN_BUFFER_INFO con = {};
    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);

    return con.wAttributes;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txSetConsoleCursorPos (double x, double y)
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   COORD pos = { (short) ROUND (1.0 * x / fontSz.x + con.srWindow.Left),
                  (short) ROUND (1.0 * y / fontSz.y + con.srWindow.Top ) };

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos) asserted;

$   POINT prev = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return prev;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleCursorPos()
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  pos = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleExtent()
    {
$1  CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  size = { con.srWindow.Right  - con.srWindow.Left + 1,
                    con.srWindow.Bottom - con.srWindow.Top  + 1 };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClearConsole()
    {
$1  HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (out, &con) asserted;

$   COORD start = {con.srWindow.Left, con.srWindow.Top};

$   DWORD len   = (con.srWindow.Right  - con.srWindow.Left + 1) *
                  (con.srWindow.Bottom - con.srWindow.Top  + 1);

$   DWORD written = 0;
$   FillConsoleOutputCharacter (out, 0x20 /*' '*/,    len, start, &written) asserted;
$   FillConsoleOutputAttribute (out, con.wAttributes, len, start, &written) asserted;

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), start) asserted;

$   return written == len;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleFontSize()
    {
$1  Win32::CONSOLE_FONT_INFO font = {0, {8, 16}};

$   _TX_CALL (Win32::GetCurrentConsoleFont, (GetStdHandle (STD_OUTPUT_HANDLE), false, &font));

$   SIZE size = { font.dwFontSize.X, font.dwFontSize.Y };
$   txGDI (Win32::GetTextExtentPoint32 (_txCanvas_BackBuf[1], "W", 1, &size), txDC());

$   POINT sizeFont = { size.cx, size.cy };
$   return sizeFont;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextCursor (bool blink /*= true*/)
    {
$1  bool old = _txConsole_IsBlinking;

$   _txConsole_IsBlinking = blink;

$   return old;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPlaySound (const char filename[] /*= NULL*/, DWORD mode /*= SND_ASYNC*/)
    {
$1  mode |= SND_FILENAME | SND_NODEFAULT | SND_NOWAIT;
$   if (mode & SND_LOOP) mode = (mode & ~SND_SYNC) | SND_ASYNC;

$   if (!filename) mode = SND_PURGE;

$   return !!Win32::PlaySound (filename, NULL, mode);
    }

//-----------------------------------------------------------------------------------------------------------------

int txSpeak (const char* text, ...)
    {
$1  bool verbose = false; (void) verbose;
$   bool async   = false; (void) async;

$   for (; text && *text; text++)
        {
        if      (*text == '\a') {$ async   = true; }
        else if (*text == '\v') {$ verbose = true; }
        else break;
        }

$   char textA [_TX_BUFSIZE] = "You asked to speak empty text. I would rather say that TX Library is cool! Cats rules!";

$   va_list arg; va_start (arg, text);
    if (text && *text) {$ _tx_vsnprintf_s (textA, sizeof (textA) - 1, text, arg); }
$   va_end (arg);

#ifdef TX_USE_SPEAK

    if (text && verbose) {$ printf ("%s", textA); }

$   int time = GetTickCount();

$   static wchar_t textW [_TX_BUFSIZE * sizeof (wchar_t)] = L"";
$   MultiByteToWideChar (_TX_CODEPAGE, 0, textA, -1, textW, sizearr (textW));

$   static ISpVoice* voice = NULL;

$   if (text && !voice)
        {
$       HRESULT res = Win32::CoInitialize (NULL);
        if (res == S_OK) {$ Win32::CoCreateInstance (Win32::CLSID_SpVoice, NULL, CLSCTX_ALL, Win32::IID_ISpVoice, (void**) &voice); }
        }

$   if (text && voice)
        {
$       Win32::_fpreset();
$       voice->Speak (textW, SPF_PERSIST_XML | SPF_PURGEBEFORESPEAK | (async? SPF_ASYNC : 0), NULL);
$       tx_fpreset();
        }

$   if (!text && voice)
        {
$       voice->Release();
$       voice = NULL;

$       Win32::CoUninitialize();
        }

$   return (voice)? GetTickCount() - time : -1;

#else

$   if (text)
        {
$       unsigned oldAttr = txSetConsoleAttr (FOREGROUND_LIGHTRED | BACKGROUND_BLACK);

$       txNotifyIcon (NIIF_ERROR, "txSpeak(): Íå ìîãó ïðîèçíåñòè (íóæåí TX_USE_SPEAK, ñì. TXLib Help)", "\n" "%s", textA);

$       txSetConsoleAttr (oldAttr);
        }

$   return -1;

#endif
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txPlayVideo (int x, int y, int width, int height, const char fileName[],
                      double zoom /*= 0*/, double gain /*= 1*/, HWND wnd /*= txWindow()*/)
    {
$1  if (wnd && wnd == txWindow() && _TX_TXWINDOW_FAILED()) return -1;

$   int time = GetTickCount();

$   static char processUID [64] = "";
    if (!*processUID)
        {
$       FILETIME startTime = {}, null = {};
$       GetProcessTimes (GetCurrentProcess(), &startTime, &null, &null, &null) asserted;
$       _snprintf_s (processUID, sizeof (processUID) - 1, "TXLib[%08X%08X]::txPlayVideo",
                    (unsigned) startTime.dwHighDateTime, (unsigned) startTime.dwLowDateTime) < (int) sizeof (processUID) asserted;
        }

$   if (!fileName)
        {
$       txTaskKill ("vlc.exe", processUID, 0);  // Kill'em all, by command line pattern
$       return 0;
        }

$   static const char* vlcPath = _txPlayVideo_FindVLC();

$   if (!vlcPath || _access (vlcPath, 0) != 0)
        {
$       static int once = false;

$       if (*fileName && !once++)
            {$ txOutputDebugPrintf ("\a" "Íå íàéäåí âèäåîïðîèãðûâàòåëü VideoLAN (vlc.exe). Cêà÷àéòå åãî ñ ñàéòà VideoLAN.org "
                                    "è óñòàíîâèòå. Áåç óñòàíîâêè VideoLAN âèäåî âîñïðîèçâîäèòüñÿ íå áóäåò :(\n\n"
                                    "--\n" "Âñåãäà Âàøà, ôóíêöèÿ " /* êàê áû */ "txPlayVideo()...\n"
                                    "P.S. Ñì. ìîå îïèñàíèå â TXLib Help."); }
$       return INT_MIN;
        }

$   bool async = false;
    if (*fileName == '\a') {$ async = true; fileName++; }

$   RECT rect = {};
    if (wnd) {$ GetClientRect (wnd, &rect); }

    if (!width)  {$ width  = rect.right;  }
    if (!height) {$ height = rect.bottom; }

    // Create a child window to hold the video stream

$   const char* errPos = "ÂÍÅÇÀÏÍÎ";

$   volatile HWND child = NULL;
$   if (wnd && (wnd == txWindow()))
        {
$       const char* wndClass = txRegisterClass ("txPlayVideo", _txPlayVideo_WndProc, 0, NULL_BRUSH, 1);

$       static int number = 1;
$       CREATESTRUCT createData = { NULL, NULL, (HMENU) (size_t) number++, txWindow(), height, width, y, x,
                                    WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, __func__, wndClass };
$       child = txCreateExtraWindow (createData);
$       if (!child)
            {
$           txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                       strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå ìîãó ñîçäàòü îêíî äëÿ âèäåî :("), errPos));
$           return INT_MIN+3;
            }

$       BringWindowToTop (child);

$       wnd = child;
        }

    // Build the command line

    if (!zoom && !wnd) {$ zoom = 1; }

$   char sZoom [64] = "--autoscale";
    if (zoom) {$ _snprintf_s (sZoom, sizeof (sZoom) - 1, "--no-autoscale --zoom=%.10g", zoom) < (int) sizeof (sZoom) asserted; }

$   static char cmd [MAX_PATH*2 + 1024] = "";

$   _snprintf_s (cmd, sizeof (cmd) - 1, "\"%s\" \"%s\" vlc://quit"

                 " %s --gain=%.10g --drawable-hwnd=%" PRIu64 " --video-title=\"%s\" --logfile=%s"

                 " --live-caching=500 --network-caching=500 --quiet-synchro --no-embedded-video --file-logging"

                 " --ignore-config --reset-config --no-one-instance --play-and-exit"
                 " --intf=dummy --dummy-quiet --quiet --no-video-deco --no-video-title-show --no-stats --no-sub-autodetect-file"
                 " --no-disable-screensaver --no-snapshot-preview --no-auto-preparse --no-mouse-events --no-keyboard-events",

                 vlcPath, (*fileName? fileName : "fileName"), sZoom, gain, (uint64_t) wnd, processUID, _txLogName) < (int) sizeof (cmd) asserted;

$   txOutputDebugPrintf ("txPlayVideo (%d, %d, %d, %d, \"%s\", %lg, %lg, %p): [%s]\n\n",
                         x, y, width, height, fileName, zoom, gain, wnd, cmd);
$   if (!*fileName)
        {
        if (child) {$ txDestroyWindow (child); }
$       return (intptr_t) cmd;
        }

$   if (!strstr (fileName, "://") && _access (fileName, 0) != 0)
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå íàéäåí ôàéë \"%s\"", fileName), errPos));

        if (child) {$ txDestroyWindow (child); }
$       return INT_MIN+1;
        }

    // Run VLC, run

$   PROCESS_INFORMATION vlc   = {};
$   STARTUPINFO         start = { sizeof (start) };
$   DWORD               ret   = 0;

$   if (CreateProcess (NULL, cmd, NULL, NULL, true, 0, NULL, NULL, &start, &vlc) &&
        vlc.hProcess && vlc.hThread)
        {
$       if (child)
            {
$           assert (wnd == child);
$           SetWindowLongPtr (wnd, GWLP_USERDATA, (LONG_PTR) vlc.hProcess);
            }

$       if (!async)
            {
$           WaitForSingleObject (vlc.hProcess, INFINITE);
$           GetExitCodeProcess  (vlc.hProcess, &ret) asserted;
            }

$       if (!child)
            {
$           CloseHandle (vlc.hProcess) asserted;
            }

$       CloseHandle (vlc.hThread) asserted;

$       return (async? (intptr_t) wnd : (ret == 0)? time - GetTickCount() : - (int) ret);
        }
    else
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Îøèáêà çàïóñêà VideoLAN (%s)", cmd), errPos));
$       if (child)
            {$ txDestroyWindow (child); }

$       return INT_MIN+4;
        }

    #undef PROCESS_UID_
    }

//-----------------------------------------------------------------------------------------------------------------

inline intptr_t txPlayVideo (const char fileName[], double zoom /*= 0*/, double gain /*= 0*/, HWND wnd /*= txWindow()*/)
    {
$1  return txPlayVideo (0, 0, 0, 0, fileName, zoom, gain, wnd);
    }

//-----------------------------------------------------------------------------------------------------------------

LRESULT CALLBACK _txPlayVideo_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
    const UINT_PTR checkTimer = 1;

    switch (msg)
        {
        case WM_CREATE:
            {
$1          SetTimer  (wnd, checkTimer, 5*_txWindowUpdateInterval, NULL) asserted;
            }
            break;

        case WM_DESTROY:
            {
$1          KillTimer (wnd, checkTimer) asserted;

$           HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

$           if (vlc)
                {
$               Win32::TerminateProcess (vlc, 0);

$               CloseHandle (vlc) asserted;

$               SetWindowLongPtr (wnd, GWLP_USERDATA, 0);
                }
            }
            break;

        case WM_TIMER:
            {
            HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

            if (vlc && WaitForSingleObject (vlc, 0) != WAIT_TIMEOUT)
                {
$1              DestroyWindow (wnd) asserted;
                }
            }
            break;

        default:
            break;
        }

    return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txPlayVideo_FindVLC()
    {
$1  static char vlcPath [MAX_PATH] = "";

$   if (SearchPath (NULL, "vlc.bat", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (SearchPath (NULL, "vlc.exe", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", NULL, vlcPath, sizeof (vlcPath)))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", "InstallDir", vlcPath, sizeof (vlcPath)))
        {
$       strncat_s (vlcPath, sizeof (vlcPath) - 1, "\\vlc.exe", INT_MAX);

        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files"    "\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   return NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// +--<<< Ýòî âðÿä ëè èìååò îòíîøåíèå ê òîìó, ÷òî âû èùåòå :)
// V      Ïîëåçíî ñìîòðåòü íå òîëüêî ââåðõ, íî è âíèç

WNDPROC txSetWindowsHook (WNDPROC wndProc /*= NULL*/)
    {
$1  WNDPROC old = _txAltWndProc; _txAltWndProc = wndProc;
$   return  old;
    }

//-----------------------------------------------------------------------------------------------------------------

//     +--<<< À ýòî, íàêîíåö, èñêîìîå îïðåäåëåíèå ýòîé ôóíêöèè.
//     |      Ñìîòðèòå ïî ñòîðîíàì! Íóæíàÿ âàì ôóíêöèÿ ãäå-òî ðÿäîì.
//     |
//     v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()
    {
    txMessageBox ("Ýòî çàïëàíèðîâàííàÿ îøèáêà. Òàêîå áûâàåò. Âû õîòåëè âûçâàòü:\n\n"

                  "txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()\n\n"

                  "Õîòü âû äîëãî [êîïèðîâàëè]íàáèðàëè ýòî èìÿ, íà ñàìîì äåëå ýòà ôóíêöèÿ íå ðåàëèçîâàíà. "
                  "Åñòü äðóãàÿ ôóíêöèÿ, êîòîðàÿ óáèðàåò àâòî-ïàóçó â êîíöå ïðîãðàììû, íî â õåëïå ïðî íåå íå íàïèñàíî.\n\n"

                  "Íî íå âñå òàê ïëîõî. Îïðåäåëåíèå íóæíîé ôóíêöèè åñòü â èñõîäíûõ òåêñòàõ TXLib.h, îíî ëåæèò ðÿäîì "
                  "ñ îïðåäåëåíèåì òîé ôóíêöèè ñ äëèííûì íàçâàíèåì, êîòîðóþ âû ñåé÷àñ âûçâàëè.\n\n"

                  "Íàæìèòå â ðåäàêòîðå Ctrl+O, íàéäèòå è îòêðîéòå ôàéë TXLib.h (îí ëåæèò â ïàïêå, êóäà âû "
                  "óñòàíîâèëè TXLib), çàòåì íàæìèòå Ctrl+F è èùèòå \"txIDontWant\". Óäà÷è!\n\n",

                  "Íå ïîëó÷èëîñü", MB_ICONSTOP);

    // The truth is out there... (C++files)

    return false;
    }

//-----------------------------------------------------------------------------------------------------------------

// Bingo! Now you are learned to use the Sources, Luke. And may the Source be with you.

inline bool txDisableAutoPause()
    {
    _txExit = true;
    return true;
    }

// P.S. This library contains more undocumented functions. Search them via "Luke" keyword.

//-----------------------------------------------------------------------------------------------------------------

void _txDump (const void* address, const char name[] /*= "_txDump()"*/, bool pause /*= true*/)
    {
$1  assert (!_txIsBadReadPtr (address));

    const unsigned char* p = (const unsigned char*) address;
$   unsigned x = 0;

$   unsigned attr = txGetConsoleAttr();

$   txSetConsoleAttr (FOREGROUND_WHITE);
$   printf ("\n%*.*s ", (int) sizeof (address) * 2, (int) sizeof (address) * 2, ((name)? name : ""));

$   txSetConsoleAttr (FOREGROUND_YELLOW);
$   for (x = 0; x < 16; x++) printf ("%02X ", x);
$   for (x = 0; x < 16; x++) printf ("%X",    x);

$   const char   isCtrl[] = "\a" "\b" "\n" "\r" "\t" "\0";
$   const char   xlatCh[] =  "·"  "·"  "·"  "·"  "·"  "·";
$   const size_t szCtrl   = sizeof (isCtrl) - 1;

$   int oldCP = GetConsoleOutputCP();

$   for (int y = 0; y < 16; y++, p += 16)
        {
        txSetConsoleAttr (FOREGROUND_YELLOW);

        printf ("\n" "%*p ", (int) sizeof (address) * 2, p);

        int color = FOREGROUND_LIGHTGREEN;

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);
            printf ("%02X ", p[x]);
            }

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);

            char c = p[x];
            const char* ctrl = (const char*) memchr (isCtrl, c, szCtrl);
            if (ctrl) c = xlatCh [ctrl - isCtrl];

            if (ctrl) SetConsoleOutputCP (1251);

            printf ("%c", c);

            if (ctrl) SetConsoleOutputCP (oldCP);
            }
        }

$   txSetConsoleAttr (attr);
$   printf ("\n");

$   if (pause)
        {
$       SetConsoleOutputCP (_TX_CODEPAGE);

$       fprintf (stderr, "[Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]                          CodePage = %5d\n", oldCP);
$       (void)_getch();

$       SetConsoleOutputCP (oldCP);
        }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txStackBackTrace (const char file[] /*= "?"*/, int line /*= 0*/, const char func[] /*= "?"*/,
                        bool readSource /*= true*/)
    {
$1  unsigned attr = txGetConsoleAttr();
$   txSetConsoleAttr (FOREGROUND_LIGHTCYAN);

$   fprintf (stderr, "\n" "--------------------------------------------------\n"
                          "Òðàññèðîâêà ñòåêà èç \"%s\" at %s (%d):\n\n"
                          "%s\n\n"
                          "--------------------------------------------------\n\n",
                          func, file, line, _txCaptureStackBackTrace (1, readSource));

$   txSetConsoleAttr (attr);
    }

//-----------------------------------------------------------------------------------------------------------------

char* txDemangle (const char* mangledName, std::nomeow_t)
    {
$1  if (!mangledName) return NULL;

$   char* typeName = NULL;

    #if defined (_GCC_VER)

$   int err = 1;
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err); (void) err;
    if (typeName) {$ return typeName; }

    #endif

$   unsigned short flags = 0;

$   if (mangledName[0] == '.')
        {
$       mangledName++;
$       flags = 0x2800;  // UNDNAME_32_BIT_DECODE | UNDNAME_TYPE_ONLY
        }

$   typeName = _TX_CALL (Win32::__unDName, (NULL, mangledName, 0, malloc, free, flags));
    if (typeName) {$ return typeName; }

$   return _strdup (mangledName);
    }

//-----------------------------------------------------------------------------------------------------------------

std::string txDemangle (const char* mangledName)
    {
$1  char* typeName = txDemangle (mangledName, std::nomeow);
$   std::string name (typeName? typeName : "");
$   free (typeName);

$   return name;
    }

//-----------------------------------------------------------------------------------------------------------------

double txQueryPerformance()
    {
$1  int maxTime    =  500;
$   int maxSamples =  100;
$   POINT size     = {100, 100};

$   HDC dc = _txBuffer_Create (txWindow(), &size, NULL);
$   assert (dc); if (!dc) return -1;

$   DWORD mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), 1);
$   assert (mask);

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   int samples = 0;
$   while (samples++ < maxSamples)
        {
$       LARGE_INTEGER cur = {};
$       QueryPerformanceCounter (&cur) asserted;

$       double t = 1000.0 * (double) (cur.QuadPart - start.QuadPart) / (double) freq.QuadPart;
$       if (t > maxTime) break;

        // Draw test scene

$       for (int y = 0; y < size.y; y++)
        for (int x = 0; x < size.x; x++)     txSetPixel (x, y, TX_BLACK, dc);

$       for (int y = 0; y < size.y; y += 10)
        for (int x = 0; x < size.x; x += 50) txTextOut  (x, y, "*", dc);

$       txEllipse (0, 0, size.x, size.y, dc);
$       txFloodFill (size.x/2, size.y/2, TX_TRANSPARENT, FLOODFILLSURFACE, dc);

$       txBitBlt (dc, size.x/2,        0, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc,        0, size.y/2) asserted;
$       txBitBlt (dc,        0, size.y/2, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, size.x/2,        0) asserted;
        }

$   mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), mask);
$   assert (mask);

$   _txBuffer_Delete (&dc);

$   return 3.0 * samples / sqrt (1.0 * size.x * size.y);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_TX_CPP11)
template <int txFramesToAverage>
#endif

double txGetFPS (int minFrames)
    {
$1  static LARGE_INTEGER time0 = {}; if (!time0.QuadPart) QueryPerformanceCounter (&time0);
$          LARGE_INTEGER time  = {};                      QueryPerformanceCounter (&time);

$   if (time.QuadPart - time0.QuadPart == 0)
        {$ return 0; }

$   LARGE_INTEGER freq = {}; QueryPerformanceFrequency (&freq);

$   double fps = (double) freq.QuadPart / (double) (time.QuadPart - time0.QuadPart);
$   time0 = time;

$   if (txFramesToAverage == 0) return fps;

$   static double average [txFramesToAverage] = {};
$   static unsigned n = 0;

$   average [n++ % txFramesToAverage] = fps;

$   unsigned nn = MIN (n, (unsigned) sizearr (average));

$   static double median  [txFramesToAverage] = {};
$   std::copy (average, average + nn, median);
$   std::nth_element (median, median + nn/2, median + nn);

$   fps = (median [(nn-1) / 2] + median [nn / 2]) / 2.0;

$   return ((int)n >= MIN (minFrames, txFramesToAverage))? fps : 0;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txExtractColor (COLORREF color, COLORREF component)
    {
$1  switch (component)
        {
        case TX_RED:
        case TX_HUE:        $ return (color >>  0) & 0xFF;

        case TX_GREEN:
        case TX_SATURATION: $ return (color >>  8) & 0xFF;

        case TX_BLUE:
        case TX_LIGHTNESS:  $ return (color >> 16) & 0xFF;

        default:            $ return CLR_INVALID;
        }
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txRGB2HSL (COLORREF rgbColor)
    {
$1  int r = (int) txExtractColor (rgbColor, TX_RED),
        g = (int) txExtractColor (rgbColor, TX_GREEN),
        b = (int) txExtractColor (rgbColor, TX_BLUE);

$   double m1 = MAX (MAX (r, g), b) / 255.0,
           m2 = MIN (MIN (r, g), b) / 255.0,
           dm = m1 - m2,
           sm = m1 + m2,

           ir = r / 255.0,
           ig = g / 255.0,
           ib = b / 255.0,

           ih = 0,
           is = 0,
           il = sm / 2;

$   const double prec = 0.001;

$   if (fabs (dm) < prec)
        {
$       is = dm / ((sm <= 1)? sm : (2-sm));

$       double cr = (m1 - ir) / dm,
               cg = (m1 - ig) / dm,
               cb = (m1 - ib) / dm;

$       if (fabs (ir - m1) < prec) ih =     cb - cg;
$       if (fabs (ig - m1) < prec) ih = 2 + cr - cb;
$       if (fabs (ib - m1) < prec) ih = 4 + cg - cr;
        }

$   ih = (ih >= 0)? ih*60 : ih*60 + 360;

$   return RGB (ROUND (ih / 360 * 255), ROUND (is * 255), ROUND (il * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txHSL2RGB (COLORREF hslColor)
    {
$1  struct xRGB
        {
        static double calc (double h, double m1, double m2)
            {
$           if (h < 0)   h += 360;
$           if (h > 360) h -= 360;

$           return (h <  60)? m1 + (m2-m1) *      h  / 60 :
                   (h < 180)? m2 :
                   (h < 240)? m1 + (m2-m1) * (240-h) / 60 :
                              m1;
            }
        };

$   int h = (int) txExtractColor (hslColor, TX_HUE),
        s = (int) txExtractColor (hslColor, TX_SATURATION),
        l = (int) txExtractColor (hslColor, TX_LIGHTNESS);

$   double ih = h / 255.0 * 360.0,
           il = l / 100.0,
           is = s / 100.0,

           m2 = (il <= 0.5)? il * (1 + is) : il + is - il * is,
           m1 = 2 * il - m2,

           ir = s? xRGB::calc (ih + 120, m1, m2) : il,
           ig = s? xRGB::calc (ih,       m1, m2) : il,
           ib = s? xRGB::calc (ih - 120, m1, m2) : il;

$   return RGB (ROUND (ir * 255), ROUND (ig * 255), ROUND (ib * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (std::nomeow_t, double left, double right)
    {
    return left + (right - left) * ((double) rand() / RAND_MAX);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (std::nomeow_t, Tx x, Ta a, Tb b)
    {
    return a <= x && x <= b;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int random (int range)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return rand() % range;
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (double left, double right)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return random (std::nomeow, left, right);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (Tx x, Ta a, Tb b)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return In (std::nomeow, x, a, b);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const POINT& pt, const RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.x, rect.left, rect.right) &&
           In (std::nomeow, pt.y, rect.top,  rect.bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const COORD& pt, const SMALL_RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.X, rect.Left, rect.Right) &&
           In (std::nomeow, pt.Y, rect.Top,  rect.Bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

void tx_fpreset()
    {
$1  txAutoLock _lock;

$   Win32::_fpreset();

$   unsigned new87 = 0x0008001C;  // _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW

    #if !defined (__CYGWIN__)

$   unsigned old87 = 0;
$   if (_controlfp_s (&old87, 0, 0) == 0)
        {$ (void) _controlfp_s (&old87, old87  & ~new87, 0x0008001F); }  // _MCW_EM

    #else

$   Win32::_controlfp (Win32::_controlfp (0, 0) & ~new87, 0x0008001F);    // _MCW_EM

    #endif
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T zero() { T __zero = {}; return __zero; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txPrintf() implementation
//           Ðåàëèçàöèÿ txPrintf()
//=================================================================================================================

#if defined (_TX_CPP11)

template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                                  const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width,                   const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                precision_t prec, const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args);
                                         void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt);

template <typename T>                    void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int*     arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt);

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg, ArgsT... args)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*') {$ stream << std::setw (width); }
    else {$ TX_ERROR ("\"%%*\" required to setwidth (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '*') {$ stream << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%.*\" required to setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*' && fmt[2] == '.' && fmt[3] == '*') {$ stream << std::setw (width) << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%*.*\" required to setwidth (%d) and setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (!fmt[0]) {$}
    else {$ TX_ERROR ("No argument provided for %% in \"%s\" while printing \"%s\"", fmt, format); }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char*, int, const char*& fmt)
    {
$1  assert (&stream);
$   assert (fmt);

$   while (*fmt)
        {
        if (fmt[0] == '%')
            {
            if (fmt[1] == '%') fmt++;
            else break;
            }

        stream << *fmt++;
        }
$   }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg)
    {
$1  assert (&stream);
$   assert (fmt);

$   if (_TX_ARGUMENT_FAILED (&arg)) return;

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   fmt++;

$   char                    oldFill  = stream.fill (' ');
$   std::ios_base::fmtflags oldFlags = stream.flags();

$   for (;;) switch (*fmt)
        {
        case '-': $ stream << std::left;     fmt++; break;
        case '+': $ stream << std::showpos;  fmt++; break;
        case ' ': $ stream.fill (' ');       fmt++; break;
        case '#': $ stream << std::showbase; fmt++; break;
        case '0': $ stream.fill ('0');       fmt++; break;

        default:  $ goto end;
        }
    end:

$   int width = (*fmt != '*')?                  (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0);
$   int prec  = (*fmt == '.')? (*++fmt != '*')? (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0) : 0;

    if (width) {$ stream << std::setw (width);        }
    if (prec)  {$ stream << std::setprecision (prec); }

$   fmt += strspn (fmt, "hljztL");

$   switch (*fmt)
        {
        case '$':
        case '?': $                                              break;

        case 'd':
        case 'i':
        case 'u': $ stream << std::dec;                          break;

        case 'o': $ stream << std::oct;                          break;

        case 'x': $ stream << std::hex;                          break;
        case 'X': $ stream << std::hex        << std::uppercase; break;

        case 'f': $ stream << std::fixed;                        break;
        case 'F': $ stream << std::fixed      << std::uppercase; break;

        case 'e': $ stream << std::scientific;                   break;
        case 'E': $ stream << std::scientific << std::uppercase; break;

        case 'g': $                                              break;
        case 'G': $ stream                    << std::uppercase; break;

        case 'a': $                                              break;
        case 'A': $ stream                    << std::uppercase; break;

        case 'c':
        case 's':
        case 'p': $                                              break;

        default:  $ TX_ERROR ("Invalid format '%.1s' at \"%s\" while printing %s argument %d in \"%s\"", fmt, fmt, txTypename (arg), n, format); break;
        }

$   fmt++;

    if (&arg) {$ stream << arg;      }
    else      {$ stream << "(null)"; }

$   stream.fill  (oldFill);
$   stream.flags (oldFlags);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int* arg)
    {
$1  assert (fmt);

    if (_TX_ARGUMENT_FAILED (arg)) return;

    if (fmt[0] == '%' && fmt[1] == 'n') {$}
    else {$ TX_ERROR ("\"%%n\" required to store print length in int* argument %d in \"%s\"", n, format); }

$   *arg = (int) stream.str().length();

$   fmt += 2;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T> inline const T&    _txPrintfNormalizeArg (const T&           arg) { if (_TX_ARGUMENT_FAILED (&arg)) {;}          return arg;         }
                      inline const char* _txPrintfNormalizeArg (const std::string& arg) { if (_TX_ARGUMENT_FAILED (&arg)) return NULL; return arg.c_str(); }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (std::ostringstream& stream, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&stream)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   const char* fmt = format;
$   _txPrintF (stream, format, 2, fmt, _txPrintfNormalizeArg (args)...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (char buffer[], size_t size, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&buffer)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   if (size > 0) size--;
$   buffer[size] = 0;

$   if (!size) return 0;

$   std::ostringstream stream;
$   stream.rdbuf() -> pubsetbuf (buffer, size);

$   txPrintf (stream, format, args...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline std::string txFormat (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return "";

$   std::ostringstream stream;

$   txPrintf (stream, format, args...);

$   return stream.str();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   return printf ("%s", txFormat (format, args...) .c_str());
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

       int _txPrintfCheck (const char* format, ...) tx_printfy (1);
inline int _txPrintfCheck (const char*,        ...) { return 0; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txDialog methods implementation
//           Ðåàëèçàöèÿ ìåòîäîâ êëàññà txDialog
//
//           See [1] http://msdn.microsoft.com/ru-ru/library/windows/desktop/ms645389%28v=vs.85%29.aspx
//               [2] http://blogs.msdn.microsoft.com/oldnewthing/20050429-00/?p=35743
//               [3] http://blogs.msdn.microsoft.com/oldnewthing/20040623-00/?p=38753
//=================================================================================================================

txDialog::txDialog () :
    layout_ (NULL)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

txDialog::txDialog (const Layout* layout) :
    layout_ (layout)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

const txDialog::Layout* txDialog::setLayout (const Layout* layout)
    {
$1  assert (layout);

$   return ::std::swap (layout_, layout), layout;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (WORD resourceID)
    {
$1  const char* resName = (char*)(uintptr_t) resourceID;

$   if (!FindResource (NULL, resName, RT_DIALOG)) return TX_DEBUG_ERROR ("Íå íàéäåí ðåñóðñ äèàëîãà %d", resourceID), 0;

$   return DialogBoxParam (NULL, resName, NULL, (DLGPROC) DialogProc_, (LPARAM) this);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (const txDialog::Layout* layout /*= NULL*/, size_t bufsize /*= 0*/)
    {
$1  if (!layout)  layout = layout_;
$   if (!layout)  return TX_DEBUG_ERROR ("Íå óñòàíîâëåí äèíàìè÷åñêèé øàáëîí äèàëîãà"), 0;

$   if (!bufsize) bufsize = 1024;

$   DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$   if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà"), 0;

$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };

$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];

$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }

$   tmpl->cdit = (unsigned short) (i-1);

$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);

$   GlobalFree (tmpl);

$   return res;
    }

//-----------------------------------------------------------------------------------------------------------------

int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;

        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;

            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }

$   return FALSE;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;

$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;

$   WORD* pw = (WORD*) globalMem;

$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;

$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }

$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   return pw;
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;

$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;

$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;

$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }

$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }

$   *pw++ = 0;

$   return pw;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================

#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$

//}
//=================================================================================================================

//! @endcond

//=================================================================================================================
//{          Experimental Debugging macros
//! @name    Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//!          âî âðåìÿ åãî âûïîëíåíèÿ.
//!
//!          Ñäåëàé ïðèÿòíûìè òâîè <i>êðóãëûå ñóòêè 
    // ýòè ðàçìåðû âñåãäà ñîâïàäàþò, è ïîýòîìó ïðè ðàáîòå ñ txAlphaBlend() ìàñøòàá áóäåò âñåãäà 1:1. <s>Òàê ñåáå ðåøåíèå, íî</s>
    // ýòî ñäåëàíî äëÿ óïðîùåíèÿ âûçîâà ôóíêöèè txAlphaBlend().
 
$   if (Win32::AlphaBlend) // Òîëüêî òî, ÷òî ýòè ïàðàìåòðû ïåðåäàþòñÿ îäèíàêîâûìè, íå äàåò âîçìîæíîñòü ìåíÿòü ìàñøòàá êàðòèíêè!   // <<--
        {                  //                           //                                       vvvvv          vvvvvv            // <<--
$       ok &= txGDI (!!(Win32::AlphaBlend (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),          // <<==
                                           sourceImage, ROUND (xSource), ROUND (ySource), ROUND (width), ROUND (height), blend)), // <<==
                                           destImage);  //                                       ^^^^^          ^^^^^^            // <<--
        }                  //                                                                    |||||          ||||||            // <<--
                           // Ñì. "AlphaBlend function" â Google, èùèòå ñìûñë ïàðàìåòðîâ wSrc è wDest (hSrc è hDest). Äóìàéòå!    // <<--
 
    else
        {
$       ok &= txGDI (!!(Win32::BitBlt     (destImage,   ROUND (xDest),   ROUND (yDest),   ROUND (width), ROUND (height),
                                           sourceImage, ROUND (xSource), ROUND (ySource), SRCCOPY)),
                                           destImage);
$       ok = false;
        }
 
    //  ýòîé ôóíêöèè ïðîâåðîê è êîììåíòàðèåâ áîëüøå, ÷åì ðàáî÷åãî êîäà, è ýòî êàê áû íàìåêàåò, ÷òî íåòðóäíî ñäåëàòü ñâîþ
    // àíàëîãè÷íóþ ôóíêöèþ áåç îãðàíè÷åíèé ìàñøòàáà îòîáðàæåíèÿ. <s>Åñëè òû äî÷èòàë äî ýòîãî ìåñòà,</s> ïåðåñÿäü ñ èãëû TXLib'à    // íà ïîâåðõíîñòü GDI Win32, <s>õîòÿ GDI òîæå òàê ñåáå, òàê ÷òî ëó÷øå çàþçàé GDI+, SFML, OpenGL èëè DirectX, áóäåò êðóòî.
    // Õîòÿ ýòî è ñëîæíåå.</s>

    // Íî ïîìíè ïðî ïàëåíûé êîïèïàñò è êàðìó, ñì. âûøå. ß ïðåäóïðåäèë.

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool txAlphaBlend (double xDest, double yDest, HDC sourceImage,
                          double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;

$   return txAlphaBlend (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, alpha);
    }

//-----------------------------------------------------------------------------------------------------------------

HDC txUseAlpha (HDC image)
    {
$1  if (_TX_HDC_FAILED (image)) return NULL;

$   HBITMAP bitmap = (HBITMAP) Win32::GetCurrentObject (image, OBJ_BITMAP);
$   if (!bitmap) return NULL;

$   DIBSECTION dib = {};
$   Win32::GetObject (bitmap, sizeof (dib), &dib) asserted;

$   POINT      size = {  dib.dsBm.bmWidth, dib.dsBm.bmHeight };
$   BITMAPINFO info = {{ sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB }};
$   RGBQUAD*   buf  = NULL;

$   bool isDIB = (dib.dsBm.bmPlanes        == 1                    &&
                  dib.dsBm.bmBitsPixel     == sizeof (RGBQUAD) * 8 &&
                  dib.dsBmih.biCompression == DIB_RGB_COLORS       &&
                  dib.dsBm.bmBits);
$   if (!isDIB)
        {
$       buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$       if (!buf) return NULL;

$       Win32::GetDIBits (image, bitmap, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;
        }
    else
        {
$       buf = (RGBQUAD*) dib.dsBm.bmBits;
        }

$   for (int y = 0; y < size.y; y++)
    for (int x = 0; x < size.x; x++)
        {
        RGBQUAD* color = &buf [x + y * size.x];  // Get color at (x, y) within image buffer

        color->rgbRed   = (BYTE) ROUND (color->rgbRed   * color->rgbReserved / 255.0);
        color->rgbGreen = (BYTE) ROUND (color->rgbGreen * color->rgbReserved / 255.0);
        color->rgbBlue  = (BYTE) ROUND (color->rgbBlue  * color->rgbReserved / 255.0);
        }

$   if (!isDIB)
        {
$       Win32::SetDIBitsToDevice (image, 0, 0, size.x, size.y, 0, 0, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;

$       delete[] buf;
        }

$   return image;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txSaveImage (const char filename[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (filename)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))       return false;

$   POINT size = txGetExtent (dc);

$   size_t szHdrs = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER),
           szImg  = (size.x * size.y) * sizeof (RGBQUAD);

$   BITMAPFILEHEADER hdr  = { 0x4D42 /* 'MB' */, (DWORD) (szHdrs + szImg), 0, 0, (DWORD) szHdrs };
$   BITMAPINFOHEADER info = { sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB };

$   bool ok = true;

$   RGBQUAD* buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$   ok &= (buf != NULL);

$   if (ok) Win32::GetDIBits (dc, (HBITMAP) Win32::GetCurrentObject (dc, OBJ_BITMAP), 0, size.y,
                              buf, (BITMAPINFO*) &info, DIB_RGB_COLORS) asserted;
$   FILE* f = NULL;
$   if (ok) fopen_s (&f, filename, "wb");
$   ok &= (f != NULL);

$   if (ok) ok &= (fwrite (&hdr,  sizeof (hdr),  1, f) == 1);
$   if (ok) ok &= (fwrite (&info, sizeof (info), 1, f) == 1);
$   if (ok) ok &= (fwrite (buf,   szImg,         1, f) == 1);

$   ok &= (f && fclose (f) == 0);

$   delete[] buf;
$   buf = NULL;

$   return ok;
    }

//-----------------------------------------------------------------------------------------------------------------

inline void txRedrawWindow()
    {
$1  txSleep (0);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txUpdateWindow (int update /*= true*/)
    {
$1  return _txCanvas_SetRefreshLock (update >= 0? !update : -update);
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txBegin()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock + 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txEnd()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock - 1);

$   return _txCanvas_RefreshLock;
    }

//-----------------------------------------------------------------------------------------------------------------

double txSleep (double time)
    {
$1  LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   int lock = _txCanvas_RefreshLock;
$   _txCanvas_RefreshLock = 0;

$   HWND wnd = txWindow();
    if (wnd) {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }

$   Sleep (ROUND ((time >= 0)? time : 0));

$   _txCanvas_RefreshLock = lock;

$   LARGE_INTEGER stop = {};
$   QueryPerformanceCounter (&stop) asserted;

$   return 1000.0 * (double) (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txLock (bool wait /*= true*/)
    {
$0  if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);

$   if (wait) {$ return      EnterCriticalSection (&_txCanvas_LockBackBuf), true; }
    else      {$ return !!TryEnterCriticalSection (&_txCanvas_LockBackBuf);       }
    }

//-----------------------------------------------------------------------------------------------------------------

bool txUnlock()
    {
$0  LeaveCriticalSection (&_txCanvas_LockBackBuf);

$   if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$   return false;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T txUnlock (T value)
    {
$1  txUnlock();
$   return value;
    }

//-----------------------------------------------------------------------------------------------------------------

inline POINT txMousePos()
    {
$1  POINT pos = {};
$   GetCursorPos (&pos);

$   if (txWindow())
        {$ ScreenToClient (txWindow(), &pos); }

$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseX()
    {
    return txMousePos() .x;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int txMouseY()
    {
    return txMousePos() .y;
    }

//-----------------------------------------------------------------------------------------------------------------

inline unsigned txMouseButtons()
    {
$1  return ((GetAsyncKeyState (VK_LBUTTON) & 0x8000) >> 15) |  // MSB to bit 0
           ((GetAsyncKeyState (VK_RBUTTON) & 0x8000) >> 14) |  // MSB to bit 1
           ((GetAsyncKeyState (VK_MBUTTON) & 0x8000) >> 13);   // MSB to bit 2
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txSetConsoleAttr (unsigned color /*= FOREGROUND_LIGHTGRAY*/)
    {
    unsigned oldAttr = txGetConsoleAttr();

    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), (WORD) color);

    return oldAttr;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txGetConsoleAttr()
    {
    CONSOLE_SCREEN_BUFFER_INFO con = {};
    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);

    return con.wAttributes;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txSetConsoleCursorPos (double x, double y)
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   COORD pos = { (short) ROUND (1.0 * x / fontSz.x + con.srWindow.Left),
                  (short) ROUND (1.0 * y / fontSz.y + con.srWindow.Top ) };

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos) asserted;

$   POINT prev = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return prev;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleCursorPos()
    {
$1  POINT fontSz = txGetConsoleFontSize();

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  pos = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return pos;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleExtent()
    {
$1  CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;

$   POINT  size = { con.srWindow.Right  - con.srWindow.Left + 1,
                    con.srWindow.Bottom - con.srWindow.Top  + 1 };
$   return size;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txClearConsole()
    {
$1  HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);

$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (out, &con) asserted;

$   COORD start = {con.srWindow.Left, con.srWindow.Top};

$   DWORD len   = (con.srWindow.Right  - con.srWindow.Left + 1) *
                  (con.srWindow.Bottom - con.srWindow.Top  + 1);

$   DWORD written = 0;
$   FillConsoleOutputCharacter (out, 0x20 /*' '*/,    len, start, &written) asserted;
$   FillConsoleOutputAttribute (out, con.wAttributes, len, start, &written) asserted;

$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), start) asserted;

$   return written == len;
    }

//-----------------------------------------------------------------------------------------------------------------

POINT txGetConsoleFontSize()
    {
$1  Win32::CONSOLE_FONT_INFO font = {0, {8, 16}};

$   _TX_CALL (Win32::GetCurrentConsoleFont, (GetStdHandle (STD_OUTPUT_HANDLE), false, &font));

$   SIZE size = { font.dwFontSize.X, font.dwFontSize.Y };
$   txGDI (Win32::GetTextExtentPoint32 (_txCanvas_BackBuf[1], "W", 1, &size), txDC());

$   POINT sizeFont = { size.cx, size.cy };
$   return sizeFont;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txTextCursor (bool blink /*= true*/)
    {
$1  bool old = _txConsole_IsBlinking;

$   _txConsole_IsBlinking = blink;

$   return old;
    }

//-----------------------------------------------------------------------------------------------------------------

bool txPlaySound (const char filename[] /*= NULL*/, DWORD mode /*= SND_ASYNC*/)
    {
$1  mode |= SND_FILENAME | SND_NODEFAULT | SND_NOWAIT;
$   if (mode & SND_LOOP) mode = (mode & ~SND_SYNC) | SND_ASYNC;

$   if (!filename) mode = SND_PURGE;

$   return !!Win32::PlaySound (filename, NULL, mode);
    }

//-----------------------------------------------------------------------------------------------------------------

int txSpeak (const char* text, ...)
    {
$1  bool verbose = false; (void) verbose;
$   bool async   = false; (void) async;

$   for (; text && *text; text++)
        {
        if      (*text == '\a') {$ async   = true; }
        else if (*text == '\v') {$ verbose = true; }
        else break;
        }

$   char textA [_TX_BUFSIZE] = "You asked to speak empty text. I would rather say that TX Library is cool! Cats rules!";

$   va_list arg; va_start (arg, text);
    if (text && *text) {$ _tx_vsnprintf_s (textA, sizeof (textA) - 1, text, arg); }
$   va_end (arg);

#ifdef TX_USE_SPEAK

    if (text && verbose) {$ printf ("%s", textA); }

$   int time = GetTickCount();

$   static wchar_t textW [_TX_BUFSIZE * sizeof (wchar_t)] = L"";
$   MultiByteToWideChar (_TX_CODEPAGE, 0, textA, -1, textW, sizearr (textW));

$   static ISpVoice* voice = NULL;

$   if (text && !voice)
        {
$       HRESULT res = Win32::CoInitialize (NULL);
        if (res == S_OK) {$ Win32::CoCreateInstance (Win32::CLSID_SpVoice, NULL, CLSCTX_ALL, Win32::IID_ISpVoice, (void**) &voice); }
        }

$   if (text && voice)
        {
$       Win32::_fpreset();
$       voice->Speak (textW, SPF_PERSIST_XML | SPF_PURGEBEFORESPEAK | (async? SPF_ASYNC : 0), NULL);
$       tx_fpreset();
        }

$   if (!text && voice)
        {
$       voice->Release();
$       voice = NULL;

$       Win32::CoUninitialize();
        }

$   return (voice)? GetTickCount() - time : -1;

#else

$   if (text)
        {
$       unsigned oldAttr = txSetConsoleAttr (FOREGROUND_LIGHTRED | BACKGROUND_BLACK);

$       txNotifyIcon (NIIF_ERROR, "txSpeak(): Íå ìîãó ïðîèçíåñòè (íóæåí TX_USE_SPEAK, ñì. TXLib Help)", "\n" "%s", textA);

$       txSetConsoleAttr (oldAttr);
        }

$   return -1;

#endif
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txPlayVideo (int x, int y, int width, int height, const char fileName[],
                      double zoom /*= 0*/, double gain /*= 1*/, HWND wnd /*= txWindow()*/)
    {
$1  if (wnd && wnd == txWindow() && _TX_TXWINDOW_FAILED()) return -1;

$   int time = GetTickCount();

$   static char processUID [64] = "";
    if (!*processUID)
        {
$       FILETIME startTime = {}, null = {};
$       GetProcessTimes (GetCurrentProcess(), &startTime, &null, &null, &null) asserted;
$       _snprintf_s (processUID, sizeof (processUID) - 1, "TXLib[%08X%08X]::txPlayVideo",
                    (unsigned) startTime.dwHighDateTime, (unsigned) startTime.dwLowDateTime) < (int) sizeof (processUID) asserted;
        }

$   if (!fileName)
        {
$       txTaskKill ("vlc.exe", processUID, 0);  // Kill'em all, by command line pattern
$       return 0;
        }

$   static const char* vlcPath = _txPlayVideo_FindVLC();

$   if (!vlcPath || _access (vlcPath, 0) != 0)
        {
$       static int once = false;

$       if (*fileName && !once++)
            {$ txOutputDebugPrintf ("\a" "Íå íàéäåí âèäåîïðîèãðûâàòåëü VideoLAN (vlc.exe). Cêà÷àéòå åãî ñ ñàéòà VideoLAN.org "
                                    "è óñòàíîâèòå. Áåç óñòàíîâêè VideoLAN âèäåî âîñïðîèçâîäèòüñÿ íå áóäåò :(\n\n"
                                    "--\n" "Âñåãäà Âàøà, ôóíêöèÿ " /* êàê áû */ "txPlayVideo()...\n"
                                    "P.S. Ñì. ìîå îïèñàíèå â TXLib Help."); }
$       return INT_MIN;
        }

$   bool async = false;
    if (*fileName == '\a') {$ async = true; fileName++; }

$   RECT rect = {};
    if (wnd) {$ GetClientRect (wnd, &rect); }

    if (!width)  {$ width  = rect.right;  }
    if (!height) {$ height = rect.bottom; }

    // Create a child window to hold the video stream

$   const char* errPos = "ÂÍÅÇÀÏÍÎ";

$   volatile HWND child = NULL;
$   if (wnd && (wnd == txWindow()))
        {
$       const char* wndClass = txRegisterClass ("txPlayVideo", _txPlayVideo_WndProc, 0, NULL_BRUSH, 1);

$       static int number = 1;
$       CREATESTRUCT createData = { NULL, NULL, (HMENU) (size_t) number++, txWindow(), height, width, y, x,
                                    WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, __func__, wndClass };
$       child = txCreateExtraWindow (createData);
$       if (!child)
            {
$           txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                       strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå ìîãó ñîçäàòü îêíî äëÿ âèäåî :("), errPos));
$           return INT_MIN+3;
            }

$       BringWindowToTop (child);

$       wnd = child;
        }

    // Build the command line

    if (!zoom && !wnd) {$ zoom = 1; }

$   char sZoom [64] = "--autoscale";
    if (zoom) {$ _snprintf_s (sZoom, sizeof (sZoom) - 1, "--no-autoscale --zoom=%.10g", zoom) < (int) sizeof (sZoom) asserted; }

$   static char cmd [MAX_PATH*2 + 1024] = "";

$   _snprintf_s (cmd, sizeof (cmd) - 1, "\"%s\" \"%s\" vlc://quit"

                 " %s --gain=%.10g --drawable-hwnd=%" PRIu64 " --video-title=\"%s\" --logfile=%s"

                 " --live-caching=500 --network-caching=500 --quiet-synchro --no-embedded-video --file-logging"

                 " --ignore-config --reset-config --no-one-instance --play-and-exit"
                 " --intf=dummy --dummy-quiet --quiet --no-video-deco --no-video-title-show --no-stats --no-sub-autodetect-file"
                 " --no-disable-screensaver --no-snapshot-preview --no-auto-preparse --no-mouse-events --no-keyboard-events",

                 vlcPath, (*fileName? fileName : "fileName"), sZoom, gain, (uint64_t) wnd, processUID, _txLogName) < (int) sizeof (cmd) asserted;

$   txOutputDebugPrintf ("txPlayVideo (%d, %d, %d, %d, \"%s\", %lg, %lg, %p): [%s]\n\n",
                         x, y, width, height, fileName, zoom, gain, wnd, cmd);
$   if (!*fileName)
        {
        if (child) {$ txDestroyWindow (child); }
$       return (intptr_t) cmd;
        }

$   if (!strstr (fileName, "://") && _access (fileName, 0) != 0)
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå íàéäåí ôàéë \"%s\"", fileName), errPos));

        if (child) {$ txDestroyWindow (child); }
$       return INT_MIN+1;
        }

    // Run VLC, run

$   PROCESS_INFORMATION vlc   = {};
$   STARTUPINFO         start = { sizeof (start) };
$   DWORD               ret   = 0;

$   if (CreateProcess (NULL, cmd, NULL, NULL, true, 0, NULL, NULL, &start, &vlc) &&
        vlc.hProcess && vlc.hThread)
        {
$       if (child)
            {
$           assert (wnd == child);
$           SetWindowLongPtr (wnd, GWLP_USERDATA, (LONG_PTR) vlc.hProcess);
            }

$       if (!async)
            {
$           WaitForSingleObject (vlc.hProcess, INFINITE);
$           GetExitCodeProcess  (vlc.hProcess, &ret) asserted;
            }

$       if (!child)
            {
$           CloseHandle (vlc.hProcess) asserted;
            }

$       CloseHandle (vlc.hThread) asserted;

$       return (async? (intptr_t) wnd : (ret == 0)? time - GetTickCount() : - (int) ret);
        }
    else
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Îøèáêà çàïóñêà VideoLAN (%s)", cmd), errPos));
$       if (child)
            {$ txDestroyWindow (child); }

$       return INT_MIN+4;
        }

    #undef PROCESS_UID_
    }

//-----------------------------------------------------------------------------------------------------------------

inline intptr_t txPlayVideo (const char fileName[], double zoom /*= 0*/, double gain /*= 0*/, HWND wnd /*= txWindow()*/)
    {
$1  return txPlayVideo (0, 0, 0, 0, fileName, zoom, gain, wnd);
    }

//-----------------------------------------------------------------------------------------------------------------

LRESULT CALLBACK _txPlayVideo_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
    const UINT_PTR checkTimer = 1;

    switch (msg)
        {
        case WM_CREATE:
            {
$1          SetTimer  (wnd, checkTimer, 5*_txWindowUpdateInterval, NULL) asserted;
            }
            break;

        case WM_DESTROY:
            {
$1          KillTimer (wnd, checkTimer) asserted;

$           HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

$           if (vlc)
                {
$               Win32::TerminateProcess (vlc, 0);

$               CloseHandle (vlc) asserted;

$               SetWindowLongPtr (wnd, GWLP_USERDATA, 0);
                }
            }
            break;

        case WM_TIMER:
            {
            HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);

            if (vlc && WaitForSingleObject (vlc, 0) != WAIT_TIMEOUT)
                {
$1              DestroyWindow (wnd) asserted;
                }
            }
            break;

        default:
            break;
        }

    return DefWindowProc (wnd, msg, wpar, lpar);
    }

//-----------------------------------------------------------------------------------------------------------------

const char* _txPlayVideo_FindVLC()
    {
$1  static char vlcPath [MAX_PATH] = "";

$   if (SearchPath (NULL, "vlc.bat", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (SearchPath (NULL, "vlc.exe", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", NULL, vlcPath, sizeof (vlcPath)))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", "InstallDir", vlcPath, sizeof (vlcPath)))
        {
$       strncat_s (vlcPath, sizeof (vlcPath) - 1, "\\vlc.exe", INT_MAX);

        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files"    "\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }

$   return NULL;
    }

//-----------------------------------------------------------------------------------------------------------------

// +--<<< Ýòî âðÿä ëè èìååò îòíîøåíèå ê òîìó, ÷òî âû èùåòå :)
// V      Ïîëåçíî ñìîòðåòü íå òîëüêî ââåðõ, íî è âíèç

WNDPROC txSetWindowsHook (WNDPROC wndProc /*= NULL*/)
    {
$1  WNDPROC old = _txAltWndProc; _txAltWndProc = wndProc;
$   return  old;
    }

//-----------------------------------------------------------------------------------------------------------------

//     +--<<< À ýòî, íàêîíåö, èñêîìîå îïðåäåëåíèå ýòîé ôóíêöèè.
//     |      Ñìîòðèòå ïî ñòîðîíàì! Íóæíàÿ âàì ôóíêöèÿ ãäå-òî ðÿäîì.
//     |
//     v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()
    {
    txMessageBox ("Ýòî çàïëàíèðîâàííàÿ îøèáêà. Òàêîå áûâàåò. Âû õîòåëè âûçâàòü:\n\n"

                  "txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()\n\n"

                  "Õîòü âû äîëãî [êîïèðîâàëè]íàáèðàëè ýòî èìÿ, íà ñàìîì äåëå ýòà ôóíêöèÿ íå ðåàëèçîâàíà. "
                  "Åñòü äðóãàÿ ôóíêöèÿ, êîòîðàÿ óáèðàåò àâòî-ïàóçó â êîíöå ïðîãðàììû, íî â õåëïå ïðî íåå íå íàïèñàíî.\n\n"

                  "Íî íå âñå òàê ïëîõî. Îïðåäåëåíèå íóæíîé ôóíêöèè åñòü â èñõîäíûõ òåêñòàõ TXLib.h, îíî ëåæèò ðÿäîì "
                  "ñ îïðåäåëåíèåì òîé ôóíêöèè ñ äëèííûì íàçâàíèåì, êîòîðóþ âû ñåé÷àñ âûçâàëè.\n\n"

                  "Íàæìèòå â ðåäàêòîðå Ctrl+O, íàéäèòå è îòêðîéòå ôàéë TXLib.h (îí ëåæèò â ïàïêå, êóäà âû "
                  "óñòàíîâèëè TXLib), çàòåì íàæìèòå Ctrl+F è èùèòå \"txIDontWant\". Óäà÷è!\n\n",

                  "Íå ïîëó÷èëîñü", MB_ICONSTOP);

    // The truth is out there... (C++files)

    return false;
    }

//-----------------------------------------------------------------------------------------------------------------

// Bingo! Now you are learned to use the Sources, Luke. And may the Source be with you.

inline bool txDisableAutoPause()
    {
    _txExit = true;
    return true;
    }

// P.S. This library contains more undocumented functions. Search them via "Luke" keyword.

//-----------------------------------------------------------------------------------------------------------------

void _txDump (const void* address, const char name[] /*= "_txDump()"*/, bool pause /*= true*/)
    {
$1  assert (!_txIsBadReadPtr (address));

    const unsigned char* p = (const unsigned char*) address;
$   unsigned x = 0;

$   unsigned attr = txGetConsoleAttr();

$   txSetConsoleAttr (FOREGROUND_WHITE);
$   printf ("\n%*.*s ", (int) sizeof (address) * 2, (int) sizeof (address) * 2, ((name)? name : ""));

$   txSetConsoleAttr (FOREGROUND_YELLOW);
$   for (x = 0; x < 16; x++) printf ("%02X ", x);
$   for (x = 0; x < 16; x++) printf ("%X",    x);

$   const char   isCtrl[] = "\a" "\b" "\n" "\r" "\t" "\0";
$   const char   xlatCh[] =  "·"  "·"  "·"  "·"  "·"  "·";
$   const size_t szCtrl   = sizeof (isCtrl) - 1;

$   int oldCP = GetConsoleOutputCP();

$   for (int y = 0; y < 16; y++, p += 16)
        {
        txSetConsoleAttr (FOREGROUND_YELLOW);

        printf ("\n" "%*p ", (int) sizeof (address) * 2, p);

        int color = FOREGROUND_LIGHTGREEN;

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);
            printf ("%02X ", p[x]);
            }

        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);

            char c = p[x];
            const char* ctrl = (const char*) memchr (isCtrl, c, szCtrl);
            if (ctrl) c = xlatCh [ctrl - isCtrl];

            if (ctrl) SetConsoleOutputCP (1251);

            printf ("%c", c);

            if (ctrl) SetConsoleOutputCP (oldCP);
            }
        }

$   txSetConsoleAttr (attr);
$   printf ("\n");

$   if (pause)
        {
$       SetConsoleOutputCP (_TX_CODEPAGE);

$       fprintf (stderr, "[Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]                          CodePage = %5d\n", oldCP);
$       (void)_getch();

$       SetConsoleOutputCP (oldCP);
        }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txStackBackTrace (const char file[] /*= "?"*/, int line /*= 0*/, const char func[] /*= "?"*/,
                        bool readSource /*= true*/)
    {
$1  unsigned attr = txGetConsoleAttr();
$   txSetConsoleAttr (FOREGROUND_LIGHTCYAN);

$   fprintf (stderr, "\n" "--------------------------------------------------\n"
                          "Òðàññèðîâêà ñòåêà èç \"%s\" at %s (%d):\n\n"
                          "%s\n\n"
                          "--------------------------------------------------\n\n",
                          func, file, line, _txCaptureStackBackTrace (1, readSource));

$   txSetConsoleAttr (attr);
    }

//-----------------------------------------------------------------------------------------------------------------

char* txDemangle (const char* mangledName, std::nomeow_t)
    {
$1  if (!mangledName) return NULL;

$   char* typeName = NULL;

    #if defined (_GCC_VER)

$   int err = 1;
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err); (void) err;
    if (typeName) {$ return typeName; }

    #endif

$   unsigned short flags = 0;

$   if (mangledName[0] == '.')
        {
$       mangledName++;
$       flags = 0x2800;  // UNDNAME_32_BIT_DECODE | UNDNAME_TYPE_ONLY
        }

$   typeName = _TX_CALL (Win32::__unDName, (NULL, mangledName, 0, malloc, free, flags));
    if (typeName) {$ return typeName; }

$   return _strdup (mangledName);
    }

//-----------------------------------------------------------------------------------------------------------------

std::string txDemangle (const char* mangledName)
    {
$1  char* typeName = txDemangle (mangledName, std::nomeow);
$   std::string name (typeName? typeName : "");
$   free (typeName);

$   return name;
    }

//-----------------------------------------------------------------------------------------------------------------

double txQueryPerformance()
    {
$1  int maxTime    =  500;
$   int maxSamples =  100;
$   POINT size     = {100, 100};

$   HDC dc = _txBuffer_Create (txWindow(), &size, NULL);
$   assert (dc); if (!dc) return -1;

$   DWORD mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), 1);
$   assert (mask);

$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;

$   LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;

$   int samples = 0;
$   while (samples++ < maxSamples)
        {
$       LARGE_INTEGER cur = {};
$       QueryPerformanceCounter (&cur) asserted;

$       double t = 1000.0 * (double) (cur.QuadPart - start.QuadPart) / (double) freq.QuadPart;
$       if (t > maxTime) break;

        // Draw test scene

$       for (int y = 0; y < size.y; y++)
        for (int x = 0; x < size.x; x++)     txSetPixel (x, y, TX_BLACK, dc);

$       for (int y = 0; y < size.y; y += 10)
        for (int x = 0; x < size.x; x += 50) txTextOut  (x, y, "*", dc);

$       txEllipse (0, 0, size.x, size.y, dc);
$       txFloodFill (size.x/2, size.y/2, TX_TRANSPARENT, FLOODFILLSURFACE, dc);

$       txBitBlt (dc, size.x/2,        0, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc,        0, size.y/2) asserted;
$       txBitBlt (dc,        0, size.y/2, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, size.x/2,        0) asserted;
        }

$   mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), mask);
$   assert (mask);

$   _txBuffer_Delete (&dc);

$   return 3.0 * samples / sqrt (1.0 * size.x * size.y);
    }

//-----------------------------------------------------------------------------------------------------------------

#if defined (_TX_CPP11)
template <int txFramesToAverage>
#endif

double txGetFPS (int minFrames)
    {
$1  static LARGE_INTEGER time0 = {}; if (!time0.QuadPart) QueryPerformanceCounter (&time0);
$          LARGE_INTEGER time  = {};                      QueryPerformanceCounter (&time);

$   if (time.QuadPart - time0.QuadPart == 0)
        {$ return 0; }

$   LARGE_INTEGER freq = {}; QueryPerformanceFrequency (&freq);

$   double fps = (double) freq.QuadPart / (double) (time.QuadPart - time0.QuadPart);
$   time0 = time;

$   if (txFramesToAverage == 0) return fps;

$   static double average [txFramesToAverage] = {};
$   static unsigned n = 0;

$   average [n++ % txFramesToAverage] = fps;

$   unsigned nn = MIN (n, (unsigned) sizearr (average));

$   static double median  [txFramesToAverage] = {};
$   std::copy (average, average + nn, median);
$   std::nth_element (median, median + nn/2, median + nn);

$   fps = (median [(nn-1) / 2] + median [nn / 2]) / 2.0;

$   return ((int)n >= MIN (minFrames, txFramesToAverage))? fps : 0;
    }

//-----------------------------------------------------------------------------------------------------------------

unsigned txExtractColor (COLORREF color, COLORREF component)
    {
$1  switch (component)
        {
        case TX_RED:
        case TX_HUE:        $ return (color >>  0) & 0xFF;

        case TX_GREEN:
        case TX_SATURATION: $ return (color >>  8) & 0xFF;

        case TX_BLUE:
        case TX_LIGHTNESS:  $ return (color >> 16) & 0xFF;

        default:            $ return CLR_INVALID;
        }
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txRGB2HSL (COLORREF rgbColor)
    {
$1  int r = (int) txExtractColor (rgbColor, TX_RED),
        g = (int) txExtractColor (rgbColor, TX_GREEN),
        b = (int) txExtractColor (rgbColor, TX_BLUE);

$   double m1 = MAX (MAX (r, g), b) / 255.0,
           m2 = MIN (MIN (r, g), b) / 255.0,
           dm = m1 - m2,
           sm = m1 + m2,

           ir = r / 255.0,
           ig = g / 255.0,
           ib = b / 255.0,

           ih = 0,
           is = 0,
           il = sm / 2;

$   const double prec = 0.001;

$   if (fabs (dm) < prec)
        {
$       is = dm / ((sm <= 1)? sm : (2-sm));

$       double cr = (m1 - ir) / dm,
               cg = (m1 - ig) / dm,
               cb = (m1 - ib) / dm;

$       if (fabs (ir - m1) < prec) ih =     cb - cg;
$       if (fabs (ig - m1) < prec) ih = 2 + cr - cb;
$       if (fabs (ib - m1) < prec) ih = 4 + cg - cr;
        }

$   ih = (ih >= 0)? ih*60 : ih*60 + 360;

$   return RGB (ROUND (ih / 360 * 255), ROUND (is * 255), ROUND (il * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

COLORREF txHSL2RGB (COLORREF hslColor)
    {
$1  struct xRGB
        {
        static double calc (double h, double m1, double m2)
            {
$           if (h < 0)   h += 360;
$           if (h > 360) h -= 360;

$           return (h <  60)? m1 + (m2-m1) *      h  / 60 :
                   (h < 180)? m2 :
                   (h < 240)? m1 + (m2-m1) * (240-h) / 60 :
                              m1;
            }
        };

$   int h = (int) txExtractColor (hslColor, TX_HUE),
        s = (int) txExtractColor (hslColor, TX_SATURATION),
        l = (int) txExtractColor (hslColor, TX_LIGHTNESS);

$   double ih = h / 255.0 * 360.0,
           il = l / 100.0,
           is = s / 100.0,

           m2 = (il <= 0.5)? il * (1 + is) : il + is - il * is,
           m1 = 2 * il - m2,

           ir = s? xRGB::calc (ih + 120, m1, m2) : il,
           ig = s? xRGB::calc (ih,       m1, m2) : il,
           ib = s? xRGB::calc (ih - 120, m1, m2) : il;

$   return RGB (ROUND (ir * 255), ROUND (ig * 255), ROUND (ib * 255));
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (std::nomeow_t, double left, double right)
    {
    return left + (right - left) * ((double) rand() / RAND_MAX);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (std::nomeow_t, Tx x, Ta a, Tb b)
    {
    return a <= x && x <= b;
    }

//-----------------------------------------------------------------------------------------------------------------

inline int random (int range)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return rand() % range;
    }

//-----------------------------------------------------------------------------------------------------------------

inline double random (double left, double right)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return random (std::nomeow, left, right);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename Tx, typename Ta, typename Tb>
inline bool In (Tx x, Ta a, Tb b)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));

    return In (std::nomeow, x, a, b);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const POINT& pt, const RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.x, rect.left, rect.right) &&
           In (std::nomeow, pt.y, rect.top,  rect.bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

inline bool In (const COORD& pt, const SMALL_RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;

    return In (std::nomeow, pt.X, rect.Left, rect.Right) &&
           In (std::nomeow, pt.Y, rect.Top,  rect.Bottom);
    }

//-----------------------------------------------------------------------------------------------------------------

void tx_fpreset()
    {
$1  txAutoLock _lock;

$   Win32::_fpreset();

$   unsigned new87 = 0x0008001C;  // _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW

    #if !defined (__CYGWIN__)

$   unsigned old87 = 0;
$   if (_controlfp_s (&old87, 0, 0) == 0)
        {$ (void) _controlfp_s (&old87, old87  & ~new87, 0x0008001F); }  // _MCW_EM

    #else

$   Win32::_controlfp (Win32::_controlfp (0, 0) & ~new87, 0x0008001F);    // _MCW_EM

    #endif
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
inline T zero() { T __zero = {}; return __zero; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txPrintf() implementation
//           Ðåàëèçàöèÿ txPrintf()
//=================================================================================================================

#if defined (_TX_CPP11)

template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                                  const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width,                   const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                precision_t prec, const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args);
                                         void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt);

template <typename T>                    void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int*     arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt);

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg, ArgsT... args)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*') {$ stream << std::setw (width); }
    else {$ TX_ERROR ("\"%%*\" required to setwidth (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '*') {$ stream << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%.*\" required to setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (fmt[0] == '%' && fmt[1] == '*' && fmt[2] == '.' && fmt[3] == '*') {$ stream << std::setw (width) << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%*.*\" required to setwidth (%d) and setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, prec, fmt, txTypename (arg), n, format); }

$   _txPrintV (stream, format, n,   fmt, arg);

$   _txPrintF (stream, format, n+1, fmt, args...);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt)
    {
$1  assert (fmt);

$   _txPrintV (stream, format, n,   fmt);

    if (!fmt[0]) {$}
    else {$ TX_ERROR ("No argument provided for %% in \"%s\" while printing \"%s\"", fmt, format); }
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char*, int, const char*& fmt)
    {
$1  assert (&stream);
$   assert (fmt);

$   while (*fmt)
        {
        if (fmt[0] == '%')
            {
            if (fmt[1] == '%') fmt++;
            else break;
            }

        stream << *fmt++;
        }
$   }

//-----------------------------------------------------------------------------------------------------------------

template <typename T>
void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg)
    {
$1  assert (&stream);
$   assert (fmt);

$   if (_TX_ARGUMENT_FAILED (&arg)) return;

    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }

$   fmt++;

$   char                    oldFill  = stream.fill (' ');
$   std::ios_base::fmtflags oldFlags = stream.flags();

$   for (;;) switch (*fmt)
        {
        case '-': $ stream << std::left;     fmt++; break;
        case '+': $ stream << std::showpos;  fmt++; break;
        case ' ': $ stream.fill (' ');       fmt++; break;
        case '#': $ stream << std::showbase; fmt++; break;
        case '0': $ stream.fill ('0');       fmt++; break;

        default:  $ goto end;
        }
    end:

$   int width = (*fmt != '*')?                  (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0);
$   int prec  = (*fmt == '.')? (*++fmt != '*')? (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0) : 0;

    if (width) {$ stream << std::setw (width);        }
    if (prec)  {$ stream << std::setprecision (prec); }

$   fmt += strspn (fmt, "hljztL");

$   switch (*fmt)
        {
        case '$':
        case '?': $                                              break;

        case 'd':
        case 'i':
        case 'u': $ stream << std::dec;                          break;

        case 'o': $ stream << std::oct;                          break;

        case 'x': $ stream << std::hex;                          break;
        case 'X': $ stream << std::hex        << std::uppercase; break;

        case 'f': $ stream << std::fixed;                        break;
        case 'F': $ stream << std::fixed      << std::uppercase; break;

        case 'e': $ stream << std::scientific;                   break;
        case 'E': $ stream << std::scientific << std::uppercase; break;

        case 'g': $                                              break;
        case 'G': $ stream                    << std::uppercase; break;

        case 'a': $                                              break;
        case 'A': $ stream                    << std::uppercase; break;

        case 'c':
        case 's':
        case 'p': $                                              break;

        default:  $ TX_ERROR ("Invalid format '%.1s' at \"%s\" while printing %s argument %d in \"%s\"", fmt, fmt, txTypename (arg), n, format); break;
        }

$   fmt++;

    if (&arg) {$ stream << arg;      }
    else      {$ stream << "(null)"; }

$   stream.fill  (oldFill);
$   stream.flags (oldFlags);
    }

//-----------------------------------------------------------------------------------------------------------------

void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int* arg)
    {
$1  assert (fmt);

    if (_TX_ARGUMENT_FAILED (arg)) return;

    if (fmt[0] == '%' && fmt[1] == 'n') {$}
    else {$ TX_ERROR ("\"%%n\" required to store print length in int* argument %d in \"%s\"", n, format); }

$   *arg = (int) stream.str().length();

$   fmt += 2;
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename T> inline const T&    _txPrintfNormalizeArg (const T&           arg) { if (_TX_ARGUMENT_FAILED (&arg)) {;}          return arg;         }
                      inline const char* _txPrintfNormalizeArg (const std::string& arg) { if (_TX_ARGUMENT_FAILED (&arg)) return NULL; return arg.c_str(); }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (std::ostringstream& stream, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&stream)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   const char* fmt = format;
$   _txPrintF (stream, format, 2, fmt, _txPrintfNormalizeArg (args)...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (char buffer[], size_t size, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&buffer)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   if (size > 0) size--;
$   buffer[size] = 0;

$   if (!size) return 0;

$   std::ostringstream stream;
$   stream.rdbuf() -> pubsetbuf (buffer, size);

$   txPrintf (stream, format, args...);

$   return (int) stream.str().length();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline std::string txFormat (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return "";

$   std::ostringstream stream;

$   txPrintf (stream, format, args...);

$   return stream.str();
    }

//-----------------------------------------------------------------------------------------------------------------

template <typename... ArgsT>
inline int txPrintf (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return 0;

$   return printf ("%s", txFormat (format, args...) .c_str());
    }

#endif

//-----------------------------------------------------------------------------------------------------------------

       int _txPrintfCheck (const char* format, ...) tx_printfy (1);
inline int _txPrintfCheck (const char*,        ...) { return 0; }

//}
//=================================================================================================================

//=================================================================================================================
//{          txDialog methods implementation
//           Ðåàëèçàöèÿ ìåòîäîâ êëàññà txDialog
//
//           See [1] http://msdn.microsoft.com/ru-ru/library/windows/desktop/ms645389%28v=vs.85%29.aspx
//               [2] http://blogs.msdn.microsoft.com/oldnewthing/20050429-00/?p=35743
//               [3] http://blogs.msdn.microsoft.com/oldnewthing/20040623-00/?p=38753
//=================================================================================================================

txDialog::txDialog () :
    layout_ (NULL)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

txDialog::txDialog (const Layout* layout) :
    layout_ (layout)
    {$1}

//-----------------------------------------------------------------------------------------------------------------

const txDialog::Layout* txDialog::setLayout (const Layout* layout)
    {
$1  assert (layout);

$   return ::std::swap (layout_, layout), layout;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (WORD resourceID)
    {
$1  const char* resName = (char*)(uintptr_t) resourceID;

$   if (!FindResource (NULL, resName, RT_DIALOG)) return TX_DEBUG_ERROR ("Íå íàéäåí ðåñóðñ äèàëîãà %d", resourceID), 0;

$   return DialogBoxParam (NULL, resName, NULL, (DLGPROC) DialogProc_, (LPARAM) this);
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t txDialog::dialogBox (const txDialog::Layout* layout /*= NULL*/, size_t bufsize /*= 0*/)
    {
$1  if (!layout)  layout = layout_;
$   if (!layout)  return TX_DEBUG_ERROR ("Íå óñòàíîâëåí äèíàìè÷åñêèé øàáëîí äèàëîãà"), 0;

$   if (!bufsize) bufsize = 1024;

$   DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$   if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà"), 0;

$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };

$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];

$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }

$   tmpl->cdit = (unsigned short) (i-1);

$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);

$   GlobalFree (tmpl);

$   return res;
    }

//-----------------------------------------------------------------------------------------------------------------

int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;

        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;

            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }

$   return FALSE;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;

$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;

$   WORD* pw = (WORD*) globalMem;

$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;

$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }

$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   return pw;
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;

$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;

$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;

$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }

$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }

$   *pw++ = 0;

$   return pw;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================

#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$

//}
//=================================================================================================================

//! @endcond

//=================================================================================================================
//{          Experimental Debugging macros
//! @name    Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//!          âî âðåìÿ åãî âûïîëíåíèÿ.
//!
//!          Ñäåëàé ïðèÿòíûìè òâîè <i>êðóãëûå ñóòêè 
    // íà ïîâåðõíîñòü GDI Win32, <s>õîòÿ GDI òîæå òàê ñåáå, òàê ÷òî ëó÷øå çàþçàé GDI+, SFML, OpenGL èëè DirectX, áóäåò êðóòî.
    // Õîòÿ ýòî è ñëîæíåå.</s>
 
    // Íî ïîìíè ïðî ïàëåíûé êîïèïàñò è êàðìó, ñì. âûøå. ß ïðåäóïðåäèë.
 
$   return ok;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline bool txAlphaBlend (double xDest, double yDest, HDC sourceImage,
                          double xSource /*= 0*/, double ySource /*= 0*/, double alpha /*= 1.0*/)
    {
$1  if (_TX_TXWINDOW_FAILED()) return false;
 
$   return txAlphaBlend (txDC(), xDest, yDest, 0, 0, sourceImage, xSource, ySource, alpha);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
HDC txUseAlpha (HDC image)
    {
$1  if (_TX_HDC_FAILED (image)) return NULL;
 
$   HBITMAP bitmap = (HBITMAP) Win32::GetCurrentObject (image, OBJ_BITMAP);
$   if (!bitmap) return NULL;
 
$   DIBSECTION dib = {};
$   Win32::GetObject (bitmap, sizeof (dib), &dib) asserted;
 
$   POINT      size = {  dib.dsBm.bmWidth, dib.dsBm.bmHeight };
$   BITMAPINFO info = {{ sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB }};
$   RGBQUAD*   buf  = NULL;
 
$   bool isDIB = (dib.dsBm.bmPlanes        == 1                    &&
                  dib.dsBm.bmBitsPixel     == sizeof (RGBQUAD) * 8 &&
                  dib.dsBmih.biCompression == DIB_RGB_COLORS       &&
                  dib.dsBm.bmBits);
$   if (!isDIB)
        {
$       buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$       if (!buf) return NULL;
 
$       Win32::GetDIBits (image, bitmap, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;
        }
    else
        {
$       buf = (RGBQUAD*) dib.dsBm.bmBits;
        }
 
$   for (int y = 0; y < size.y; y++)
    for (int x = 0; x < size.x; x++)
        {
        RGBQUAD* color = &buf [x + y * size.x];  // Get color at (x, y) within image buffer
 
        color->rgbRed   = (BYTE) ROUND (color->rgbRed   * color->rgbReserved / 255.0);
        color->rgbGreen = (BYTE) ROUND (color->rgbGreen * color->rgbReserved / 255.0);
        color->rgbBlue  = (BYTE) ROUND (color->rgbBlue  * color->rgbReserved / 255.0);
        }
 
$   if (!isDIB)
        {
$       Win32::SetDIBitsToDevice (image, 0, 0, size.x, size.y, 0, 0, 0, size.y, buf, &info, DIB_RGB_COLORS) asserted;
 
$       delete[] buf;
        }
 
$   return image;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txSaveImage (const char filename[], HDC dc /*= txDC()*/)
    {
$1  if (_TX_ARGUMENT_FAILED    (filename)) return false;
$   if (_TX_DEFAULT_HDC_FAILED (dc))       return false;
 
$   POINT size = txGetExtent (dc);
 
$   size_t szHdrs = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER),
           szImg  = (size.x * size.y) * sizeof (RGBQUAD);
 
$   BITMAPFILEHEADER hdr  = { 0x4D42 /* 'MB' */, (DWORD) (szHdrs + szImg), 0, 0, (DWORD) szHdrs };
$   BITMAPINFOHEADER info = { sizeof (info), size.x, size.y, 1, (WORD) (sizeof (RGBQUAD) * 8), BI_RGB };
 
$   bool ok = true;
 
$   RGBQUAD* buf = new (std::nothrow) RGBQUAD [size.x * size.y];
$   ok &= (buf != NULL);
 
$   if (ok) Win32::GetDIBits (dc, (HBITMAP) Win32::GetCurrentObject (dc, OBJ_BITMAP), 0, size.y,
                              buf, (BITMAPINFO*) &info, DIB_RGB_COLORS) asserted;
$   FILE* f = NULL;
$   if (ok) fopen_s (&f, filename, "wb");
$   ok &= (f != NULL);
 
$   if (ok) ok &= (fwrite (&hdr,  sizeof (hdr),  1, f) == 1);
$   if (ok) ok &= (fwrite (&info, sizeof (info), 1, f) == 1);
$   if (ok) ok &= (fwrite (buf,   szImg,         1, f) == 1);
 
$   ok &= (f && fclose (f) == 0);
 
$   delete[] buf;
$   buf = NULL;
 
$   return ok;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline void txRedrawWindow()
    {
$1  txSleep (0);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline int txUpdateWindow (int update /*= true*/)
    {
$1  return _txCanvas_SetRefreshLock (update >= 0? !update : -update);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline int txBegin()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock + 1);
 
$   return _txCanvas_RefreshLock;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline int txEnd()
    {
$1  _txCanvas_SetRefreshLock (_txCanvas_RefreshLock - 1);
 
$   return _txCanvas_RefreshLock;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
double txSleep (double time)
    {
$1  LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;
 
$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;
 
$   int lock = _txCanvas_RefreshLock;
$   _txCanvas_RefreshLock = 0;
 
$   HWND wnd = txWindow();
    if (wnd) {$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }
 
$   Sleep (ROUND ((time >= 0)? time : 0));
 
$   _txCanvas_RefreshLock = lock;
 
$   LARGE_INTEGER stop = {};
$   QueryPerformanceCounter (&stop) asserted;
 
$   return 1000.0 * (double) (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txLock (bool wait /*= true*/)
    {
$0  if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
 
$   if (wait) {$ return      EnterCriticalSection (&_txCanvas_LockBackBuf), true; }
    else      {$ return !!TryEnterCriticalSection (&_txCanvas_LockBackBuf);       }
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txUnlock()
    {
$0  LeaveCriticalSection (&_txCanvas_LockBackBuf);
 
$   if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$   return false;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline T txUnlock (T value)
    {
$1  txUnlock();
$   return value;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline POINT txMousePos()
    {
$1  POINT pos = {};
$   GetCursorPos (&pos);
 
$   if (txWindow())
        {$ ScreenToClient (txWindow(), &pos); }
 
$   return pos;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline int txMouseX()
    {
    return txMousePos() .x;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline int txMouseY()
    {
    return txMousePos() .y;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline unsigned txMouseButtons()
    {
$1  return ((GetAsyncKeyState (VK_LBUTTON) & 0x8000) >> 15) |  // MSB to bit 0
           ((GetAsyncKeyState (VK_RBUTTON) & 0x8000) >> 14) |  // MSB to bit 1
           ((GetAsyncKeyState (VK_MBUTTON) & 0x8000) >> 13);   // MSB to bit 2
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
unsigned txSetConsoleAttr (unsigned color /*= FOREGROUND_LIGHTGRAY*/)
    {
    unsigned oldAttr = txGetConsoleAttr();
 
    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), (WORD) color);
 
    return oldAttr;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
unsigned txGetConsoleAttr()
    {
    CONSOLE_SCREEN_BUFFER_INFO con = {};
    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
 
    return con.wAttributes;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
POINT txSetConsoleCursorPos (double x, double y)
    {
$1  POINT fontSz = txGetConsoleFontSize();
 
$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;
 
$   COORD pos = { (short) ROUND (1.0 * x / fontSz.x + con.srWindow.Left),
                  (short) ROUND (1.0 * y / fontSz.y + con.srWindow.Top ) };
 
$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos) asserted;
 
$   POINT prev = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return prev;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
POINT txGetConsoleCursorPos()
    {
$1  POINT fontSz = txGetConsoleFontSize();
 
$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;
 
$   POINT  pos = { ROUND ((con.dwCursorPosition.X - con.srWindow.Left) * fontSz.x),
                   ROUND ((con.dwCursorPosition.Y - con.srWindow.Top ) * fontSz.y) };
$   return pos;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
POINT txGetConsoleExtent()
    {
$1  CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;
 
$   POINT  size = { con.srWindow.Right  - con.srWindow.Left + 1,
                    con.srWindow.Bottom - con.srWindow.Top  + 1 };
$   return size;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txClearConsole()
    {
$1  HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);
 
$   CONSOLE_SCREEN_BUFFER_INFO con = {};
$   GetConsoleScreenBufferInfo (out, &con) asserted;
 
$   COORD start = {con.srWindow.Left, con.srWindow.Top};
 
$   DWORD len   = (con.srWindow.Right  - con.srWindow.Left + 1) *
                  (con.srWindow.Bottom - con.srWindow.Top  + 1);
 
$   DWORD written = 0;
$   FillConsoleOutputCharacter (out, 0x20 /*' '*/,    len, start, &written) asserted;
$   FillConsoleOutputAttribute (out, con.wAttributes, len, start, &written) asserted;
 
$   SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), start) asserted;
 
$   return written == len;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
POINT txGetConsoleFontSize()
    {
$1  Win32::CONSOLE_FONT_INFO font = {0, {8, 16}};
 
$   _TX_CALL (Win32::GetCurrentConsoleFont, (GetStdHandle (STD_OUTPUT_HANDLE), false, &font));
 
$   SIZE size = { font.dwFontSize.X, font.dwFontSize.Y };
$   txGDI (Win32::GetTextExtentPoint32 (_txCanvas_BackBuf[1], "W", 1, &size), txDC());
 
$   POINT sizeFont = { size.cx, size.cy };
$   return sizeFont;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txTextCursor (bool blink /*= true*/)
    {
$1  bool old = _txConsole_IsBlinking;
 
$   _txConsole_IsBlinking = blink;
 
$   return old;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
bool txPlaySound (const char filename[] /*= NULL*/, DWORD mode /*= SND_ASYNC*/)
    {
$1  mode |= SND_FILENAME | SND_NODEFAULT | SND_NOWAIT;
$   if (mode & SND_LOOP) mode = (mode & ~SND_SYNC) | SND_ASYNC;
 
$   if (!filename) mode = SND_PURGE;
 
$   return !!Win32::PlaySound (filename, NULL, mode);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int txSpeak (const char* text, ...)
    {
$1  bool verbose = false; (void) verbose;
$   bool async   = false; (void) async;
 
$   for (; text && *text; text++)
        {
        if      (*text == '\a') {$ async   = true; }
        else if (*text == '\v') {$ verbose = true; }
        else break;
        }
 
$   char textA [_TX_BUFSIZE] = "You asked to speak empty text. I would rather say that TX Library is cool! Cats rules!";
 
$   va_list arg; va_start (arg, text);
    if (text && *text) {$ _tx_vsnprintf_s (textA, sizeof (textA) - 1, text, arg); }
$   va_end (arg);
 
#ifdef TX_USE_SPEAK
 
    if (text && verbose) {$ printf ("%s", textA); }
 
$   int time = GetTickCount();
 
$   static wchar_t textW [_TX_BUFSIZE * sizeof (wchar_t)] = L"";
$   MultiByteToWideChar (_TX_CODEPAGE, 0, textA, -1, textW, sizearr (textW));
 
$   static ISpVoice* voice = NULL;
 
$   if (text && !voice)
        {
$       HRESULT res = Win32::CoInitialize (NULL);
        if (res == S_OK) {$ Win32::CoCreateInstance (Win32::CLSID_SpVoice, NULL, CLSCTX_ALL, Win32::IID_ISpVoice, (void**) &voice); }
        }
 
$   if (text && voice)
        {
$       Win32::_fpreset();
$       voice->Speak (textW, SPF_PERSIST_XML | SPF_PURGEBEFORESPEAK | (async? SPF_ASYNC : 0), NULL);
$       tx_fpreset();
        }
 
$   if (!text && voice)
        {
$       voice->Release();
$       voice = NULL;
 
$       Win32::CoUninitialize();
        }
 
$   return (voice)? GetTickCount() - time : -1;
 
#else
 
$   if (text)
        {
$       unsigned oldAttr = txSetConsoleAttr (FOREGROUND_LIGHTRED | BACKGROUND_BLACK);
 
$       txNotifyIcon (NIIF_ERROR, "txSpeak(): Íå ìîãó ïðîèçíåñòè (íóæåí TX_USE_SPEAK, ñì. TXLib Help)", "\n" "%s", textA);
 
$       txSetConsoleAttr (oldAttr);
        }
 
$   return -1;
 
#endif
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
intptr_t txPlayVideo (int x, int y, int width, int height, const char fileName[],
                      double zoom /*= 0*/, double gain /*= 1*/, HWND wnd /*= txWindow()*/)
    {
$1  if (wnd && wnd == txWindow() && _TX_TXWINDOW_FAILED()) return -1;
 
$   int time = GetTickCount();
 
$   static char processUID [64] = "";
    if (!*processUID)
        {
$       FILETIME startTime = {}, null = {};
$       GetProcessTimes (GetCurrentProcess(), &startTime, &null, &null, &null) asserted;
$       _snprintf_s (processUID, sizeof (processUID) - 1, "TXLib[%08X%08X]::txPlayVideo",
                    (unsigned) startTime.dwHighDateTime, (unsigned) startTime.dwLowDateTime) < (int) sizeof (processUID) asserted;
        }
 
$   if (!fileName)
        {
$       txTaskKill ("vlc.exe", processUID, 0);  // Kill'em all, by command line pattern
$       return 0;
        }
 
$   static const char* vlcPath = _txPlayVideo_FindVLC();
 
$   if (!vlcPath || _access (vlcPath, 0) != 0)
        {
$       static int once = false;
 
$       if (*fileName && !once++)
            {$ txOutputDebugPrintf ("\a" "Íå íàéäåí âèäåîïðîèãðûâàòåëü VideoLAN (vlc.exe). Cêà÷àéòå åãî ñ ñàéòà VideoLAN.org "
                                    "è óñòàíîâèòå. Áåç óñòàíîâêè VideoLAN âèäåî âîñïðîèçâîäèòüñÿ íå áóäåò :(\n\n"
                                    "--\n" "Âñåãäà Âàøà, ôóíêöèÿ " /* êàê áû */ "txPlayVideo()...\n"
                                    "P.S. Ñì. ìîå îïèñàíèå â TXLib Help."); }
$       return INT_MIN;
        }
 
$   bool async = false;
    if (*fileName == '\a') {$ async = true; fileName++; }
 
$   RECT rect = {};
    if (wnd) {$ GetClientRect (wnd, &rect); }
 
    if (!width)  {$ width  = rect.right;  }
    if (!height) {$ height = rect.bottom; }
 
    // Create a child window to hold the video stream
 
$   const char* errPos = "ÂÍÅÇÀÏÍÎ";
 
$   volatile HWND child = NULL;
$   if (wnd && (wnd == txWindow()))
        {
$       const char* wndClass = txRegisterClass ("txPlayVideo", _txPlayVideo_WndProc, 0, NULL_BRUSH, 1);
 
$       static int number = 1;
$       CREATESTRUCT createData = { NULL, NULL, (HMENU) (size_t) number++, txWindow(), height, width, y, x,
                                    WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, __func__, wndClass };
$       child = txCreateExtraWindow (createData);
$       if (!child)
            {
$           txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                       strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå ìîãó ñîçäàòü îêíî äëÿ âèäåî :("), errPos));
$           return INT_MIN+3;
            }
 
$       BringWindowToTop (child);
 
$       wnd = child;
        }
 
    // Build the command line
 
    if (!zoom && !wnd) {$ zoom = 1; }
 
$   char sZoom [64] = "--autoscale";
    if (zoom) {$ _snprintf_s (sZoom, sizeof (sZoom) - 1, "--no-autoscale --zoom=%.10g", zoom) < (int) sizeof (sZoom) asserted; }
 
$   static char cmd [MAX_PATH*2 + 1024] = "";
 
$   _snprintf_s (cmd, sizeof (cmd) - 1, "\"%s\" \"%s\" vlc://quit"
 
                 " %s --gain=%.10g --drawable-hwnd=%" PRIu64 " --video-title=\"%s\" --logfile=%s"
 
                 " --live-caching=500 --network-caching=500 --quiet-synchro --no-embedded-video --file-logging"
 
                 " --ignore-config --reset-config --no-one-instance --play-and-exit"
                 " --intf=dummy --dummy-quiet --quiet --no-video-deco --no-video-title-show --no-stats --no-sub-autodetect-file"
                 " --no-disable-screensaver --no-snapshot-preview --no-auto-preparse --no-mouse-events --no-keyboard-events",
 
                 vlcPath, (*fileName? fileName : "fileName"), sZoom, gain, (uint64_t) wnd, processUID, _txLogName) < (int) sizeof (cmd) asserted;
 
$   txOutputDebugPrintf ("txPlayVideo (%d, %d, %d, %d, \"%s\", %lg, %lg, %p): [%s]\n\n",
                         x, y, width, height, fileName, zoom, gain, wnd, cmd);
$   if (!*fileName)
        {
        if (child) {$ txDestroyWindow (child); }
$       return (intptr_t) cmd;
        }
 
$   if (!strstr (fileName, "://") && _access (fileName, 0) != 0)
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "\n" "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Íå íàéäåí ôàéë \"%s\"", fileName), errPos));
 
        if (child) {$ txDestroyWindow (child); }
$       return INT_MIN+1;
        }
 
    // Run VLC, run
 
$   PROCESS_INFORMATION vlc   = {};
$   STARTUPINFO         start = { sizeof (start) };
$   DWORD               ret   = 0;
 
$   if (CreateProcess (NULL, cmd, NULL, NULL, true, 0, NULL, NULL, &start, &vlc) &&
        vlc.hProcess && vlc.hThread)
        {
$       if (child)
            {
$           assert (wnd == child);
$           SetWindowLongPtr (wnd, GWLP_USERDATA, (LONG_PTR) vlc.hProcess);
            }
 
$       if (!async)
            {
$           WaitForSingleObject (vlc.hProcess, INFINITE);
$           GetExitCodeProcess  (vlc.hProcess, &ret) asserted;
            }
 
$       if (!child)
            {
$           CloseHandle (vlc.hProcess) asserted;
            }
 
$       CloseHandle (vlc.hThread) asserted;
 
$       return (async? (intptr_t) wnd : (ret == 0)? time - GetTickCount() : - (int) ret);
        }
    else
        {
$       txNotifyIcon (NIIF_ERROR, "txPlayVideo() ñîîáùàåò", "%s",
                                   strstr (_txError (NULL, 0, NULL, 0, "\f" "Îøèáêà çàïóñêà VideoLAN (%s)", cmd), errPos));
$       if (child)
            {$ txDestroyWindow (child); }
 
$       return INT_MIN+4;
        }
 
    #undef PROCESS_UID_
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline intptr_t txPlayVideo (const char fileName[], double zoom /*= 0*/, double gain /*= 0*/, HWND wnd /*= txWindow()*/)
    {
$1  return txPlayVideo (0, 0, 0, 0, fileName, zoom, gain, wnd);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
LRESULT CALLBACK _txPlayVideo_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
    {
    const UINT_PTR checkTimer = 1;
 
    switch (msg)
        {
        case WM_CREATE:
            {
$1          SetTimer  (wnd, checkTimer, 5*_txWindowUpdateInterval, NULL) asserted;
            }
            break;
 
        case WM_DESTROY:
            {
$1          KillTimer (wnd, checkTimer) asserted;
 
$           HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);
 
$           if (vlc)
                {
$               Win32::TerminateProcess (vlc, 0);
 
$               CloseHandle (vlc) asserted;
 
$               SetWindowLongPtr (wnd, GWLP_USERDATA, 0);
                }
            }
            break;
 
        case WM_TIMER:
            {
            HANDLE vlc = (HANDLE)(uintptr_t) GetWindowLongPtr (wnd, GWLP_USERDATA);
 
            if (vlc && WaitForSingleObject (vlc, 0) != WAIT_TIMEOUT)
                {
$1              DestroyWindow (wnd) asserted;
                }
            }
            break;
 
        default:
            break;
        }
 
    return DefWindowProc (wnd, msg, wpar, lpar);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
const char* _txPlayVideo_FindVLC()
    {
$1  static char vlcPath [MAX_PATH] = "";
 
$   if (SearchPath (NULL, "vlc.bat", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }
 
$   if (SearchPath (NULL, "vlc.exe", NULL, sizeof (vlcPath), vlcPath, NULL))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }
 
$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", NULL, vlcPath, sizeof (vlcPath)))
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }
 
$   if (txRegQuery ("HKLM\\Software\\VideoLAN\\VLC", "InstallDir", vlcPath, sizeof (vlcPath)))
        {
$       strncat_s (vlcPath, sizeof (vlcPath) - 1, "\\vlc.exe", INT_MAX);
 
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }
 
$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files"    "\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }
 
$   strncpy_s (vlcPath, sizeof (vlcPath), "C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe", UINT_MAX);
        {
        if (_access (vlcPath, 0) == 0) {$ return vlcPath; }
        }
 
$   return NULL;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
// +--<<< Ýòî âðÿä ëè èìååò îòíîøåíèå ê òîìó, ÷òî âû èùåòå :)
// V      Ïîëåçíî ñìîòðåòü íå òîëüêî ââåðõ, íî è âíèç
 
WNDPROC txSetWindowsHook (WNDPROC wndProc /*= NULL*/)
    {
$1  WNDPROC old = _txAltWndProc; _txAltWndProc = wndProc;
$   return  old;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
//     +--<<< À ýòî, íàêîíåö, èñêîìîå îïðåäåëåíèå ýòîé ôóíêöèè.
//     |      Ñìîòðèòå ïî ñòîðîíàì! Íóæíàÿ âàì ôóíêöèÿ ãäå-òî ðÿäîì.
//     |
//     v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()
    {
    txMessageBox ("Ýòî çàïëàíèðîâàííàÿ îøèáêà. Òàêîå áûâàåò. Âû õîòåëè âûçâàòü:\n\n"
 
                  "txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()\n\n"
 
                  "Õîòü âû äîëãî [êîïèðîâàëè]íàáèðàëè ýòî èìÿ, íà ñàìîì äåëå ýòà ôóíêöèÿ íå ðåàëèçîâàíà. "
                  "Åñòü äðóãàÿ ôóíêöèÿ, êîòîðàÿ óáèðàåò àâòî-ïàóçó â êîíöå ïðîãðàììû, íî â õåëïå ïðî íåå íå íàïèñàíî.\n\n"
 
                  "Íî íå âñå òàê ïëîõî. Îïðåäåëåíèå íóæíîé ôóíêöèè åñòü â èñõîäíûõ òåêñòàõ TXLib.h, îíî ëåæèò ðÿäîì "
                  "ñ îïðåäåëåíèåì òîé ôóíêöèè ñ äëèííûì íàçâàíèåì, êîòîðóþ âû ñåé÷àñ âûçâàëè.\n\n"
 
                  "Íàæìèòå â ðåäàêòîðå Ctrl+O, íàéäèòå è îòêðîéòå ôàéë TXLib.h (îí ëåæèò â ïàïêå, êóäà âû "
                  "óñòàíîâèëè TXLib), çàòåì íàæìèòå Ctrl+F è èùèòå \"txIDontWant\". Óäà÷è!\n\n",
 
                  "Íå ïîëó÷èëîñü", MB_ICONSTOP);
 
    // The truth is out there... (C++files)
 
    return false;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
// Bingo! Now you are learned to use the Sources, Luke. And may the Source be with you.
 
inline bool txDisableAutoPause()
    {
    _txExit = true;
    return true;
    }
 
// P.S. This library contains more undocumented functions. Search them via "Luke" keyword.
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txDump (const void* address, const char name[] /*= "_txDump()"*/, bool pause /*= true*/)
    {
$1  assert (!_txIsBadReadPtr (address));
 
    const unsigned char* p = (const unsigned char*) address;
$   unsigned x = 0;
 
$   unsigned attr = txGetConsoleAttr();
 
$   txSetConsoleAttr (FOREGROUND_WHITE);
$   printf ("\n%*.*s ", (int) sizeof (address) * 2, (int) sizeof (address) * 2, ((name)? name : ""));
 
$   txSetConsoleAttr (FOREGROUND_YELLOW);
$   for (x = 0; x < 16; x++) printf ("%02X ", x);
$   for (x = 0; x < 16; x++) printf ("%X",    x);
 
$   const char   isCtrl[] = "\a" "\b" "\n" "\r" "\t" "\0";
$   const char   xlatCh[] =  "·"  "·"  "·"  "·"  "·"  "·";
$   const size_t szCtrl   = sizeof (isCtrl) - 1;
 
$   int oldCP = GetConsoleOutputCP();
 
$   for (int y = 0; y < 16; y++, p += 16)
        {
        txSetConsoleAttr (FOREGROUND_YELLOW);
 
        printf ("\n" "%*p ", (int) sizeof (address) * 2, p);
 
        int color = FOREGROUND_LIGHTGREEN;
 
        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);
            printf ("%02X ", p[x]);
            }
 
        for (x = 0; x < 16; x++)
            {
            txSetConsoleAttr (color + x/4%2);
 
            char c = p[x];
            const char* ctrl = (const char*) memchr (isCtrl, c, szCtrl);
            if (ctrl) c = xlatCh [ctrl - isCtrl];
 
            if (ctrl) SetConsoleOutputCP (1251);
 
            printf ("%c", c);
 
            if (ctrl) SetConsoleOutputCP (oldCP);
            }
        }
 
$   txSetConsoleAttr (attr);
$   printf ("\n");
 
$   if (pause)
        {
$       SetConsoleOutputCP (_TX_CODEPAGE);
 
$       fprintf (stderr, "[Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]                          CodePage = %5d\n", oldCP);
$       (void)_getch();
 
$       SetConsoleOutputCP (oldCP);
        }
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txStackBackTrace (const char file[] /*= "?"*/, int line /*= 0*/, const char func[] /*= "?"*/,
                        bool readSource /*= true*/)
    {
$1  unsigned attr = txGetConsoleAttr();
$   txSetConsoleAttr (FOREGROUND_LIGHTCYAN);
 
$   fprintf (stderr, "\n" "--------------------------------------------------\n"
                          "Òðàññèðîâêà ñòåêà èç \"%s\" at %s (%d):\n\n"
                          "%s\n\n"
                          "--------------------------------------------------\n\n",
                          func, file, line, _txCaptureStackBackTrace (1, readSource));
 
$   txSetConsoleAttr (attr);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
char* txDemangle (const char* mangledName, std::nomeow_t)
    {
$1  if (!mangledName) return NULL;
 
$   char* typeName = NULL;
 
    #if defined (_GCC_VER)
 
$   int err = 1;
$   typeName = ::abi::__cxa_demangle (mangledName, 0, 0, &err); (void) err;
    if (typeName) {$ return typeName; }
 
    #endif
 
$   unsigned short flags = 0;
 
$   if (mangledName[0] == '.')
        {
$       mangledName++;
$       flags = 0x2800;  // UNDNAME_32_BIT_DECODE | UNDNAME_TYPE_ONLY
        }
 
$   typeName = _TX_CALL (Win32::__unDName, (NULL, mangledName, 0, malloc, free, flags));
    if (typeName) {$ return typeName; }
 
$   return _strdup (mangledName);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
std::string txDemangle (const char* mangledName)
    {
$1  char* typeName = txDemangle (mangledName, std::nomeow);
$   std::string name (typeName? typeName : "");
$   free (typeName);
 
$   return name;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
double txQueryPerformance()
    {
$1  int maxTime    =  500;
$   int maxSamples =  100;
$   POINT size     = {100, 100};
 
$   HDC dc = _txBuffer_Create (txWindow(), &size, NULL);
$   assert (dc); if (!dc) return -1;
 
$   DWORD mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), 1);
$   assert (mask);
 
$   LARGE_INTEGER freq = {};
$   QueryPerformanceFrequency (&freq) asserted;
 
$   LARGE_INTEGER start = {};
$   QueryPerformanceCounter (&start) asserted;
 
$   int samples = 0;
$   while (samples++ < maxSamples)
        {
$       LARGE_INTEGER cur = {};
$       QueryPerformanceCounter (&cur) asserted;
 
$       double t = 1000.0 * (double) (cur.QuadPart - start.QuadPart) / (double) freq.QuadPart;
$       if (t > maxTime) break;
 
        // Draw test scene
 
$       for (int y = 0; y < size.y; y++)
        for (int x = 0; x < size.x; x++)     txSetPixel (x, y, TX_BLACK, dc);
 
$       for (int y = 0; y < size.y; y += 10)
        for (int x = 0; x < size.x; x += 50) txTextOut  (x, y, "*", dc);
 
$       txEllipse (0, 0, size.x, size.y, dc);
$       txFloodFill (size.x/2, size.y/2, TX_TRANSPARENT, FLOODFILLSURFACE, dc);
 
$       txBitBlt (dc, size.x/2,        0, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc,        0, size.y/2) asserted;
$       txBitBlt (dc,        0, size.y/2, size.x/2, size.y/2, dc,        0,        0) asserted;
$       txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, size.x/2,        0) asserted;
        }
 
$   mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), mask);
$   assert (mask);
 
$   _txBuffer_Delete (&dc);
 
$   return 3.0 * samples / sqrt (1.0 * size.x * size.y);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
#if defined (_TX_CPP11)
template <int txFramesToAverage>
#endif
 
double txGetFPS (int minFrames)
    {
$1  static LARGE_INTEGER time0 = {}; if (!time0.QuadPart) QueryPerformanceCounter (&time0);
$          LARGE_INTEGER time  = {};                      QueryPerformanceCounter (&time);
 
$   if (time.QuadPart - time0.QuadPart == 0)
        {$ return 0; }
 
$   LARGE_INTEGER freq = {}; QueryPerformanceFrequency (&freq);
 
$   double fps = (double) freq.QuadPart / (double) (time.QuadPart - time0.QuadPart);
$   time0 = time;
 
$   if (txFramesToAverage == 0) return fps;
 
$   static double average [txFramesToAverage] = {};
$   static unsigned n = 0;
 
$   average [n++ % txFramesToAverage] = fps;
 
$   unsigned nn = MIN (n, (unsigned) sizearr (average));
 
$   static double median  [txFramesToAverage] = {};
$   std::copy (average, average + nn, median);
$   std::nth_element (median, median + nn/2, median + nn);
 
$   fps = (median [(nn-1) / 2] + median [nn / 2]) / 2.0;
 
$   return ((int)n >= MIN (minFrames, txFramesToAverage))? fps : 0;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
unsigned txExtractColor (COLORREF color, COLORREF component)
    {
$1  switch (component)
        {
        case TX_RED:
        case TX_HUE:        $ return (color >>  0) & 0xFF;
 
        case TX_GREEN:
        case TX_SATURATION: $ return (color >>  8) & 0xFF;
 
        case TX_BLUE:
        case TX_LIGHTNESS:  $ return (color >> 16) & 0xFF;
 
        default:            $ return CLR_INVALID;
        }
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
COLORREF txRGB2HSL (COLORREF rgbColor)
    {
$1  int r = (int) txExtractColor (rgbColor, TX_RED),
        g = (int) txExtractColor (rgbColor, TX_GREEN),
        b = (int) txExtractColor (rgbColor, TX_BLUE);
 
$   double m1 = MAX (MAX (r, g), b) / 255.0,
           m2 = MIN (MIN (r, g), b) / 255.0,
           dm = m1 - m2,
           sm = m1 + m2,
 
           ir = r / 255.0,
           ig = g / 255.0,
           ib = b / 255.0,
 
           ih = 0,
           is = 0,
           il = sm / 2;
 
$   const double prec = 0.001;
 
$   if (fabs (dm) < prec)
        {
$       is = dm / ((sm <= 1)? sm : (2-sm));
 
$       double cr = (m1 - ir) / dm,
               cg = (m1 - ig) / dm,
               cb = (m1 - ib) / dm;
 
$       if (fabs (ir - m1) < prec) ih =     cb - cg;
$       if (fabs (ig - m1) < prec) ih = 2 + cr - cb;
$       if (fabs (ib - m1) < prec) ih = 4 + cg - cr;
        }
 
$   ih = (ih >= 0)? ih*60 : ih*60 + 360;
 
$   return RGB (ROUND (ih / 360 * 255), ROUND (is * 255), ROUND (il * 255));
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
COLORREF txHSL2RGB (COLORREF hslColor)
    {
$1  struct xRGB
        {
        static double calc (double h, double m1, double m2)
            {
$           if (h < 0)   h += 360;
$           if (h > 360) h -= 360;
 
$           return (h <  60)? m1 + (m2-m1) *      h  / 60 :
                   (h < 180)? m2 :
                   (h < 240)? m1 + (m2-m1) * (240-h) / 60 :
                              m1;
            }
        };
 
$   int h = (int) txExtractColor (hslColor, TX_HUE),
        s = (int) txExtractColor (hslColor, TX_SATURATION),
        l = (int) txExtractColor (hslColor, TX_LIGHTNESS);
 
$   double ih = h / 255.0 * 360.0,
           il = l / 100.0,
           is = s / 100.0,
 
           m2 = (il <= 0.5)? il * (1 + is) : il + is - il * is,
           m1 = 2 * il - m2,
 
           ir = s? xRGB::calc (ih + 120, m1, m2) : il,
           ig = s? xRGB::calc (ih,       m1, m2) : il,
           ib = s? xRGB::calc (ih - 120, m1, m2) : il;
 
$   return RGB (ROUND (ir * 255), ROUND (ig * 255), ROUND (ib * 255));
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline double random (std::nomeow_t, double left, double right)
    {
    return left + (right - left) * ((double) rand() / RAND_MAX);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename Tx, typename Ta, typename Tb>
inline bool In (std::nomeow_t, Tx x, Ta a, Tb b)
    {
    return a <= x && x <= b;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline int random (int range)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));
 
    return rand() % range;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline double random (double left, double right)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));
 
    return random (std::nomeow, left, right);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename Tx, typename Ta, typename Tb>
inline bool In (Tx x, Ta a, Tb b)
    {
    if (rand() % 100 == 0) fprintf (stderr, "%.4s ", (const volatile char*) ((rand() & 0x0F)? &_txCanaryFirst : &_txCanaryLast));
 
    return In (std::nomeow, x, a, b);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline bool In (const POINT& pt, const RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;
 
    return In (std::nomeow, pt.x, rect.left, rect.right) &&
           In (std::nomeow, pt.y, rect.top,  rect.bottom);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
inline bool In (const COORD& pt, const SMALL_RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&pt))   return false;
    if (_TX_ARGUMENT_FAILED (&rect)) return false;
 
    return In (std::nomeow, pt.X, rect.Left, rect.Right) &&
           In (std::nomeow, pt.Y, rect.Top,  rect.Bottom);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void tx_fpreset()
    {
$1  txAutoLock _lock;
 
$   Win32::_fpreset();
 
$   unsigned new87 = 0x0008001C;  // _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW
 
    #if !defined (__CYGWIN__)
 
$   unsigned old87 = 0;
$   if (_controlfp_s (&old87, 0, 0) == 0)
        {$ (void) _controlfp_s (&old87, old87  & ~new87, 0x0008001F); }  // _MCW_EM
 
    #else
 
$   Win32::_controlfp (Win32::_controlfp (0, 0) & ~new87, 0x0008001F);    // _MCW_EM
 
    #endif
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline T zero() { T __zero = {}; return __zero; }
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          txPrintf() implementation
//           Ðåàëèçàöèÿ txPrintf()
//=================================================================================================================
 
#if defined (_TX_CPP11)
 
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                                  const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width,                   const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt,                precision_t prec, const T& arg, ArgsT... args);
template <typename T, typename... ArgsT> void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args);
                                         void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt);
 
template <typename T>                    void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int*     arg);
                                         void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt);
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg, ArgsT... args)
    {
$1  assert (fmt);
 
$   _txPrintV (stream, format, n,   fmt);
 
    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }
 
$   _txPrintV (stream, format, n,   fmt, arg);
 
$   _txPrintF (stream, format, n+1, fmt, args...);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);
 
$   _txPrintV (stream, format, n,   fmt);
 
    if (fmt[0] == '%' && fmt[1] == '*') {$ stream << std::setw (width); }
    else {$ TX_ERROR ("\"%%*\" required to setwidth (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, fmt, txTypename (arg), n, format); }
 
$   _txPrintV (stream, format, n,   fmt, arg);
 
$   _txPrintF (stream, format, n+1, fmt, args...);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);
 
$   _txPrintV (stream, format, n,   fmt);
 
    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '*') {$ stream << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%.*\" required to setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", prec, fmt, txTypename (arg), n, format); }
 
$   _txPrintV (stream, format, n,   fmt, arg);
 
$   _txPrintF (stream, format, n+1, fmt, args...);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T, typename... ArgsT>
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt, width_t width, precision_t prec, const T& arg, ArgsT... args)
    {
$1  assert (&stream);
$   assert (fmt);
 
$   _txPrintV (stream, format, n,   fmt);
 
    if (fmt[0] == '%' && fmt[1] == '*' && fmt[2] == '.' && fmt[3] == '*') {$ stream << std::setw (width) << std::setprecision (prec+1); }
    else {$ TX_ERROR ("\"%%*.*\" required to setwidth (%d) and setprecision (%d) in ...\"%s\" while printing %s argument %d in \"%s\"", width, prec, fmt, txTypename (arg), n, format); }
 
$   _txPrintV (stream, format, n,   fmt, arg);
 
$   _txPrintF (stream, format, n+1, fmt, args...);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txPrintF (std::ostringstream& stream, const char* format, int n, const char*& fmt)
    {
$1  assert (fmt);
 
$   _txPrintV (stream, format, n,   fmt);
 
    if (!fmt[0]) {$}
    else {$ TX_ERROR ("No argument provided for %% in \"%s\" while printing \"%s\"", fmt, format); }
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txPrintV (std::ostringstream& stream, const char*, int, const char*& fmt)
    {
$1  assert (&stream);
$   assert (fmt);
 
$   while (*fmt)
        {
        if (fmt[0] == '%')
            {
            if (fmt[1] == '%') fmt++;
            else break;
            }
 
        stream << *fmt++;
        }
$   }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T>
void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, const T& arg)
    {
$1  assert (&stream);
$   assert (fmt);
 
$   if (_TX_ARGUMENT_FAILED (&arg)) return;
 
    if (fmt[0] == '%') {$}
    else {$ TX_ERROR ("\"%%$\" required to print an argument in ...\"%s\" while printing %s argument %d in \"%s\"", fmt, txTypename (arg), n, format); }
 
$   fmt++;
 
$   char                    oldFill  = stream.fill (' ');
$   std::ios_base::fmtflags oldFlags = stream.flags();
 
$   for (;;) switch (*fmt)
        {
        case '-': $ stream << std::left;     fmt++; break;
        case '+': $ stream << std::showpos;  fmt++; break;
        case ' ': $ stream.fill (' ');       fmt++; break;
        case '#': $ stream << std::showbase; fmt++; break;
        case '0': $ stream.fill ('0');       fmt++; break;
 
        default:  $ goto end;
        }
    end:
 
$   int width = (*fmt != '*')?                  (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0);
$   int prec  = (*fmt == '.')? (*++fmt != '*')? (int) strtoul (fmt, const_cast <char**> (&fmt), 10) : (fmt++, 0) : 0;
 
    if (width) {$ stream << std::setw (width);        }
    if (prec)  {$ stream << std::setprecision (prec); }
 
$   fmt += strspn (fmt, "hljztL");
 
$   switch (*fmt)
        {
        case '$':
        case '?': $                                              break;
 
        case 'd':
        case 'i':
        case 'u': $ stream << std::dec;                          break;
 
        case 'o': $ stream << std::oct;                          break;
 
        case 'x': $ stream << std::hex;                          break;
        case 'X': $ stream << std::hex        << std::uppercase; break;
 
        case 'f': $ stream << std::fixed;                        break;
        case 'F': $ stream << std::fixed      << std::uppercase; break;
 
        case 'e': $ stream << std::scientific;                   break;
        case 'E': $ stream << std::scientific << std::uppercase; break;
 
        case 'g': $                                              break;
        case 'G': $ stream                    << std::uppercase; break;
 
        case 'a': $                                              break;
        case 'A': $ stream                    << std::uppercase; break;
 
        case 'c':
        case 's':
        case 'p': $                                              break;
 
        default:  $ TX_ERROR ("Invalid format '%.1s' at \"%s\" while printing %s argument %d in \"%s\"", fmt, fmt, txTypename (arg), n, format); break;
        }
 
$   fmt++;
 
    if (&arg) {$ stream << arg;      }
    else      {$ stream << "(null)"; }
 
$   stream.fill  (oldFill);
$   stream.flags (oldFlags);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void _txPrintV (std::ostringstream& stream, const char* format, int n, const char*& fmt, int* arg)
    {
$1  assert (fmt);
 
    if (_TX_ARGUMENT_FAILED (arg)) return;
 
    if (fmt[0] == '%' && fmt[1] == 'n') {$}
    else {$ TX_ERROR ("\"%%n\" required to store print length in int* argument %d in \"%s\"", n, format); }
 
$   *arg = (int) stream.str().length();
 
$   fmt += 2;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T> inline const T&    _txPrintfNormalizeArg (const T&           arg) { if (_TX_ARGUMENT_FAILED (&arg)) {;}          return arg;         }
                      inline const char* _txPrintfNormalizeArg (const std::string& arg) { if (_TX_ARGUMENT_FAILED (&arg)) return NULL; return arg.c_str(); }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename... ArgsT>
inline int txPrintf (std::ostringstream& stream, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&stream)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;
 
$   const char* fmt = format;
$   _txPrintF (stream, format, 2, fmt, _txPrintfNormalizeArg (args)...);
 
$   return (int) stream.str().length();
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename... ArgsT>
inline int txPrintf (char buffer[], size_t size, const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&buffer)) return 0;
$   if (_TX_ARGUMENT_FAILED (&format)) return 0;
 
$   if (size > 0) size--;
$   buffer[size] = 0;
 
$   if (!size) return 0;
 
$   std::ostringstream stream;
$   stream.rdbuf() -> pubsetbuf (buffer, size);
 
$   txPrintf (stream, format, args...);
 
$   return (int) stream.str().length();
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename... ArgsT>
inline std::string txFormat (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return "";
 
$   std::ostringstream stream;
 
$   txPrintf (stream, format, args...);
 
$   return stream.str();
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename... ArgsT>
inline int txPrintf (const char* format, ArgsT... args)
    {
$1  if (_TX_ARGUMENT_FAILED (&format)) return 0;
 
$   return printf ("%s", txFormat (format, args...) .c_str());
    }
 
#endif
 
//-----------------------------------------------------------------------------------------------------------------
 
       int _txPrintfCheck (const char* format, ...) tx_printfy (1);
inline int _txPrintfCheck (const char*,        ...) { return 0; }
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          txDialog methods implementation
//           Ðåàëèçàöèÿ ìåòîäîâ êëàññà txDialog
//
//           See [1] http://msdn.microsoft.com/ru-ru/library/windows/desktop/ms645389%28v=vs.85%29.aspx
//               [2] http://blogs.msdn.microsoft.com/oldnewthing/20050429-00/?p=35743
//               [3] http://blogs.msdn.microsoft.com/oldnewthing/20040623-00/?p=38753
//=================================================================================================================
 
txDialog::txDialog () :
    layout_ (NULL)
    {$1}
 
//-----------------------------------------------------------------------------------------------------------------
 
txDialog::txDialog (const Layout* layout) :
    layout_ (layout)
    {$1}
 
//-----------------------------------------------------------------------------------------------------------------
 
const txDialog::Layout* txDialog::setLayout (const Layout* layout)
    {
$1  assert (layout);
 
$   return ::std::swap (layout_, layout), layout;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
intptr_t txDialog::dialogBox (WORD resourceID)
    {
$1  const char* resName = (char*)(uintptr_t) resourceID;
 
$   if (!FindResource (NULL, resName, RT_DIALOG)) return TX_DEBUG_ERROR ("Íå íàéäåí ðåñóðñ äèàëîãà %d", resourceID), 0;
 
$   return DialogBoxParam (NULL, resName, NULL, (DLGPROC) DialogProc_, (LPARAM) this);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
intptr_t txDialog::dialogBox (const txDialog::Layout* layout /*= NULL*/, size_t bufsize /*= 0*/)
    {
$1  if (!layout)  layout = layout_;
$   if (!layout)  return TX_DEBUG_ERROR ("Íå óñòàíîâëåí äèíàìè÷åñêèé øàáëîí äèàëîãà), 0;

$   if (!bufsize) bufsize = 1024;

$   DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$   if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà"), 0;

$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };

$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];

$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }

$   tmpl->cdit = (unsigned short) (i-1);

$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);

$   GlobalFree (tmpl);

$   return res;
    }

//-----------------------------------------------------------------------------------------------------------------

int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;

        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;

            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }

$   return FALSE;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;

$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;

$   WORD* pw = (WORD*) globalMem;

$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;

$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }

$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   return pw;
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;

$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;

$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;

$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }

$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }

$   *pw++ = 0;

$   return pw;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================

#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$

//}
//=================================================================================================================

//! @endcond

//=================================================================================================================
//{          Experimental Debugging macros
//! @name    Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//!          âî âðåìÿ åãî âûïîëíåíèÿ.
//!
//!          Ñäåëàé ïðèÿòíûìè òâîè <i>êðóãëûå ñóòêè), 0;
 
$   if (!bufsize) bufsize = 1024;
 
$   DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$   if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà), 0;

$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };

$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];

$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }

$   tmpl->cdit = (unsigned short) (i-1);

$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);

$   GlobalFree (tmpl);

$   return res;
    }

//-----------------------------------------------------------------------------------------------------------------

int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;

        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;

            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }

$   return FALSE;
    }

//-----------------------------------------------------------------------------------------------------------------

intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;

$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;

$   WORD* pw = (WORD*) globalMem;

$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;

$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }

$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }

$   return pw;
    }

//-----------------------------------------------------------------------------------------------------------------

void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;

$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;

$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;

$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;

$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }

$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }

$   *pw++ = 0;

$   return pw;
    }

//}
//=================================================================================================================

//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================

#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$

//}
//=================================================================================================================

//! @endcond

//=================================================================================================================
//{          Experimental Debugging macros
//! @name    Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================

//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief   Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//!          âî âðåìÿ åãî âûïîëíåíèÿ.
//!
//!          Ñäåëàé ïðèÿòíûìè òâîè <i>êðóãëûå ñóòêè), 0;
 
$   const Layout* dlg = &layout[0];
$   const Layout  def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };
 
$   void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
                                       (dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
                                        dlg->x, dlg->y, dlg->sx, dlg->sy,
                                        dlg->caption?  dlg->caption  : def.caption,
                                        dlg->font?     dlg->font     : def.font,
                                        dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$   WORD i = 0;
$   for (i = 1; layout[i].wndclass != END; ++i)
        {
$       const Layout* item = &layout[i];
 
$       ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
                                   item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
                                   item->id, (const char*)(uintptr_t) item->wndclass, item->caption);
        }
 
$   tmpl->cdit = (unsigned short) (i-1);
 
$   intptr_t res = DialogBoxIndirectParam (NULL, tmpl, NULL, (DLGPROC) DialogProc_, (LPARAM) this);
 
$   GlobalFree (tmpl);
 
$   return res;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
int txDialog::dialogProc (HWND wnd, UINT msg, WPARAM wParam, LPARAM)
    {
$1  switch (msg)
        {
        case WM_INITDIALOG: $ SetForegroundWindow (wnd);
                            $ break;
 
        case WM_COMMAND:    $ switch (LOWORD (wParam))
            {
            case IDOK:
            case IDCANCEL:  $ SetForegroundWindow (txWindow()? txWindow() : Win32::GetConsoleWindow());
                            $ EndDialog (wnd, (uintptr_t) this);
                            $ break;
 
            default:        $ break;
            }
                            $ break;
        default:            $ break;
        }
 
$   return FALSE;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
intptr_t CALLBACK txDialog::DialogProc_ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
$1  static txDialog* this__ = NULL;
$   if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$   if (!this__) return FALSE;
 
$   return this__-> dialogProc (wnd, msg, wParam, lParam);
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
                              WORD controls, short x, short y, short cx, short cy,
                              const char caption[], const char font[], WORD fontsize, const char menu[])
    {
$1  if (_TX_ARGUMENT_FAILED (globalMem)) return NULL;
 
$   WORD* pw = (WORD*) globalMem;
 
$   DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;
 
$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->cdit  = controls;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
 
$   if (menu > (const char*) 0xFFFF)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (menu?    menu    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
    else
        {
$       *pw++ = (WORD)(uintptr_t) (menu? 0xFFFF : 0);
$       *pw++ = (WORD)(uintptr_t)  menu;
        }
 
$   if (caption)
        {
$       pw  += MultiByteToWideChar  (_TX_CODEPAGE, 0, (caption? caption : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
 
$   if (style & DS_SETFONT)
        {
$       *pw++ = fontsize;
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, (font?    font    : ""), -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) globalMem) : 0xFFFF));
        }
 
$   return pw;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
                           short x, short y, short cx, short cy,
                           WORD id, const char wclass[], const char caption[])
    {
$1  if (_TX_ARGUMENT_FAILED (dlgTemplatePtr)) return NULL;
 
$   WORD* pw = (LPWORD) dlgTemplatePtr;  // Force align at word boundary
$   ((ULONG&) pw)  += 3;
$   ((ULONG&) pw) >>= 2;
$   ((ULONG&) pw) <<= 2;
 
$   DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;
 
$   tmpl->style = style;
$   tmpl->dwExtendedStyle = exStyle;
$   tmpl->x     = x;
$   tmpl->y     = y;
$   tmpl->cx    = cx;
$   tmpl->cy    = cy;
$   tmpl->id    = id;
 
$   if (HIWORD (wclass) == 0xFFFF)
        {
$       *pw++ = (WORD) (HIWORD ((uintptr_t) wclass));
$       *pw++ = (WORD) (LOWORD ((uintptr_t) wclass));
        }
    else if (wclass)
        {
$       pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
                                   (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
        }
    else
        {
$       *pw++ = 0;
        }
 
$   if (caption)
         {
$        pw  += MultiByteToWideChar (_TX_CODEPAGE, 0, caption, -1, (wchar_t*) pw,
                                    (int) (bufsize? bufsize - ((char*) pw - (char*) dlgTemplatePtr) : 0xFFFF));
         }
    else
        {
$       *pw++ = 0;
        }
 
$   *pw++ = 0;
 
$   return pw;
    }
 
//}
//=================================================================================================================
 
//=================================================================================================================
//{          Cleaning up the utility macros
//           Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================
 
#undef       $
#undef       $0
#undef       $1
#undef       $2
#undef       $3
#undef       $4
#undef       $5
#undef       $6
#undef       $7
#undef       $8
#undef       $9
#undef       $$
 
//}
//=================================================================================================================
 
 
//=================================================================================================================
//{          Experimental Debugging macros
//=================================================================================================================
 
//{----------------------------------------------------------------------------------------------------------------
//}----------------------------------------------------------------------------------------------------------------
 
#ifndef __TX_DEBUG_MACROS
#define __TX_DEBUG_MACROS  ("Ãðóïïà îòëàäî÷íûõ $-ìàêðîñîâ")
 
//-----------------------------------------------------------------------------------------------------------------
 
#define $H            txSetConsoleAttr (FOREGROUND_BLACK        | BACKGROUND_BLACK);
#define $B            txSetConsoleAttr (FOREGROUND_BLUE         | BACKGROUND_BLACK);
#define $G            txSetConsoleAttr (FOREGROUND_GREEN        | BACKGROUND_BLACK);
#define $C            txSetConsoleAttr (FOREGROUND_CYAN         | BACKGROUND_BLACK);
#define $R            txSetConsoleAttr (FOREGROUND_RED          | BACKGROUND_BLACK);
#define $M            txSetConsoleAttr (FOREGROUND_MAGENTA      | BACKGROUND_BLACK);
#define $Y            txSetConsoleAttr (FOREGROUND_DARKYELLOW   | BACKGROUND_BLACK);
#define $d            txSetConsoleAttr (FOREGROUND_LIGHTGRAY    | BACKGROUND_BLACK);
#define $D            txSetConsoleAttr (FOREGROUND_DARKGRAY     | BACKGROUND_BLACK);
#define $b            txSetConsoleAttr (FOREGROUND_LIGHTBLUE    | BACKGROUND_BLACK);
#define $g            txSetConsoleAttr (FOREGROUND_LIGHTGREEN   | BACKGROUND_BLACK);
#define $c            txSetConsoleAttr (FOREGROUND_LIGHTCYAN    | BACKGROUND_BLACK);
#define $r            txSetConsoleAttr (FOREGROUND_LIGHTRED     | BACKGROUND_BLACK);
#define $m            txSetConsoleAttr (FOREGROUND_LIGHTMAGENTA | BACKGROUND_BLACK);
#define $y            txSetConsoleAttr (FOREGROUND_YELLOW       | BACKGROUND_BLACK);
#define $h            txSetConsoleAttr (FOREGROUND_WHITE        | BACKGROUND_BLACK);
 
#define $i            txSetConsoleAttr (FOREGROUND_LIGHTCYAN    | BACKGROUND_BLUE);
#define $I            txSetConsoleAttr (FOREGROUND_YELLOW       | BACKGROUND_BLUE);
#define $o            txSetConsoleAttr (FOREGROUND_LIGHTGREEN   | BACKGROUND_GREEN);
#define $O            txSetConsoleAttr (FOREGROUND_YELLOW       | BACKGROUND_GREEN);
#define $e            txSetConsoleAttr (FOREGROUND_WHITE        | BACKGROUND_RED);
#define $E            txSetConsoleAttr (FOREGROUND_YELLOW       | BACKGROUND_RED);
#define $w            txSetConsoleAttr (FOREGROUND_LIGHTMAGENTA | BACKGROUND_MAGENTA);
#define $W            txSetConsoleAttr (FOREGROUND_YELLOW       | BACKGROUND_MAGENTA);
#define $f            txSetConsoleAttr (FOREGROUND_BLACK        | BACKGROUND_LIGHTRED);
#define $F            txSetConsoleAttr (FOREGROUND_MAGENTA      | BACKGROUND_LIGHTRED);
#define $l            txSetConsoleAttr (FOREGROUND_BLACK        | BACKGROUND_DARKGRAY);
#define $L            txSetConsoleAttr (FOREGROUND_LIGHTGRAY    | BACKGROUND_DARKGRAY);
 
#define $T( cond )    txSetConsoleAttr ((cond)? FOREGROUND_LIGHTGREEN : FOREGROUND_LIGHTRED );
 
#define $s            _txSaveConsoleAttr TX_JOIN (__txSavedConsoleAttrs, __LINE__);
 
#define $sH           $s $H
#define $sB           $s $B
#define $sG           $s $G
#define $sC           $s $C
#define $sR           $s $R
#define $sM           $s $M
#define $sY           $s $Y
#define $sd           $s $d
#define $sD           $s $D
#define $sb           $s $b
#define $sg           $s $g
#define $sc           $s $c
#define $sr           $s $r
#define $sm           $s $m
#define $sy           $s $y
#define $sh           $s $h
 
#define $si           $s $i
#define $sI           $s $I
#define $so           $s $o
#define $sO           $s $O
#define $se           $s $e
#define $sE           $s $E
#define $sw           $s $w
#define $sW           $s $W
#define $sf           $s $f
#define $sF           $s $F
#define $sl           $s $l
#define $sL           $s $L
 
#define $sT( cond )   $s $T (cond)
 
#define $test(cond)   { if (!!(cond)) { $o std::cerr << "[PASSED] " __TX_FILELINE__ ": " #cond; } \
                        else          { $e std::cerr << "[FAILED] " __TX_FILELINE__ ": " #cond; } $d; }
 
#define $status(cond) $test (cond)
 
#define $unittest( code, expected )                                                                                             \
    {                                                                                                                           \
    const _tx_decltype (code)     & _result   = (code);       /* Should use auto, but g++ 4.7.2 default std is < 2011 */        \
    const _tx_decltype (expected) & _expected = (expected);                                                                     \
                                                                                                                                \
    if (_result == _expected)                                                                                                   \
        { $so std::cerr << "[PASSED] " __TX_FILELINE__ ": " #code; }                                                            \
    else                                                                                                                        \
        { $se std::cerr << "[FAILED] " __TX_FILELINE__ ": " #code " == (" << _result << "), should be (" << _expected << ")"; } \
                                                                                                                                \
    $n;                                                                                                                         \
    (_result == _expected);                                                                                                     \
    }
 
//=================================================================================================================
 
#ifdef _GCC_VER
 
#define $V(  var, ...)       (               _txDumpVar ((var),  "[",             __VA_ARGS__ "]\n") )
#define $V_( var, ...)       (               _txDumpVar ((var),  "[",             __VA_ARGS__ "] " ) )
#define $V__(var, ...)       (               _txDumpVar ((var),  "[",             __VA_ARGS__ "]"  ) )
 
#define $(   var, ...)       (               _txDumpVar ((var),  "[" #var " = ",  __VA_ARGS__ "]\n") )
#define $_(  var, ...)       (               _txDumpVar ((var),  "[" #var " = ",  __VA_ARGS__ "] " ) )
#define $__( var, ...)       (               _txDumpVar ((var),  "[" #var " = ",  __VA_ARGS__ "]"  ) )
 
#define $x(  var, ...)       (               _txDumpVar ((var),  "[" #var " = ",  __VA_ARGS__ "]\n", ::std::ios_base::showbase | ::std::ios_base::hex) )
#define $x_( var, ...)       (               _txDumpVar ((var),  "[" #var " = ",  __VA_ARGS__ "] ",  ::std::ios_base::showbase | ::std::ios_base::hex) )
 
#define $v(  var, cond, ...) { { $st (cond); _txDumpVar ((var),  "[" #var " = ",  __VA_ARGS__ "]" ); } $n; }
#define $v_( var, cond, ...) {   $st (cond); _txDumpVar ((var),  "[" #var " = ",  __VA_ARGS__ "]" );       }
 
#else
 
#define $V(  var, ...)       (               _txDumpVar ((var),  "[",            #__VA_ARGS__ "]\n") )
#define $V_( var, ...)       (               _txDumpVar ((var),  "[",            #__VA_ARGS__ "] " ) )
#define $V__(var, ...)       (               _txDumpVar ((var),  "[",            #__VA_ARGS__ "]"  ) )
 
#define $(   var, ...)       (               _txDumpVar ((var),  "[" #var " = ", #__VA_ARGS__ "]\n") )
#define $_(  var, ...)       (               _txDumpVar ((var),  "[" #var " = ", #__VA_ARGS__ "] " ) )
#define $__( var, ...)       (               _txDumpVar ((var),  "[" #var " = ", #__VA_ARGS__ "]"  ) )
 
#define $x(  var, ...)       (               _txDumpVar ((var),  "[" #var " = ", #__VA_ARGS__ "]\n", ::std::ios_base::showbase | ::std::ios_base::hex) )
#define $x_( var, ...)       (               _txDumpVar ((var),  "[" #var " = ", #__VA_ARGS__ "] ",  ::std::ios_base::showbase | ::std::ios_base::hex) )
 
#define $v(  var, cond, ...) { { $st (cond); _txDumpVar ((var),  "[" #var " = ", #__VA_ARGS__ "]" ); } $n; }
#define $v_( var, cond, ...) {   $st (cond); _txDumpVar ((var),  "[" #var " = ", #__VA_ARGS__ "]" );       }
 
#endif
 
#define $$                   { txOutputDebugPrintf ("\f\n"); { $sC txOutputDebugPrintf ("\f" "[%s (%d) %s]", __FILE__, __LINE__, __TX_FUNCTION__);                                   } txOutputDebugPrintf ("\f\n"); }
#define $$_                  { txOutputDebugPrintf ("\f\n"); { $sC txOutputDebugPrintf ("\f" "[" "(%d) %s]",           __LINE__, __func__);                                          } txOutputDebugPrintf ("\f\n"); }
#define $meow(...)           { txOutputDebugPrintf ("\f\n"); { $sc txOutputDebugPrintf ("\f" "[%s (%d) %s]", __FILE__, __LINE__, __func__); txOutputDebugPrintf ("\f " __VA_ARGS__); } txOutputDebugPrintf ("\f\n"); }
#define $meow_               { txOutputDebugPrintf ("\f\n"); { $sc txOutputDebugPrintf ("\f" "[%s (%d) %s]", __FILE__, __LINE__, __func__); txOutputDebugPrintf ("\f");              } txOutputDebugPrintf ("\f\n"); }
 
#define $$$(   ... )         ( ::std::cerr << "\n[" __TX_FILELINE__ ": " #__VA_ARGS__ "]\n", _txDumpVar ((__VA_ARGS__),"\n[" __TX_FILELINE__ ": " #__VA_ARGS__ ": ", ", DONE]\n\n") )
#define $$$_(  ... )         ( ::std::cerr << "\n[" __TX_FILELINE__ ": " #__VA_ARGS__ "]\n", _txDumpVar ((__VA_ARGS__),  "[" __TX_FILELINE__ ": " #__VA_ARGS__ ": ", ", DONE]\n\n") )
 
#define $$$$(  ... )         { ::std::cerr << "\n[" __TX_FILELINE__ ": " #__VA_ARGS__ "]\n"; _txDumpVarSuffix         ("\n[" __TX_FILELINE__ ": " #__VA_ARGS__        " DONE]\n\n"); { __VA_ARGS__; } }
#define $$$$_( ... )         { ::std::cerr << "\n[" __TX_FILELINE__ ": " #__VA_ARGS__ "]\n"; _txDumpVarSuffix         (  "[" __TX_FILELINE__ ": " #__VA_ARGS__        " DONE]\n\n"); { __VA_ARGS__; } }
#define $do(   ... )           ::std::cerr << "\n[" __TX_FILELINE__ ": " #__VA_ARGS__ "]\n";                                                                                           __VA_ARGS__
#define $DO(   ... )           ::std::cerr << "\n[" __TX_FILELINE__ ": " #__VA_ARGS__ "]...\n"; $p;                                                                                    __VA_ARGS__
#define $Do(   ... )           ::std::cerr << "\n[" __TX_FILELINE__ ": " #__VA_ARGS__ "]...\n";                                                                                        \
                               txMessageBox ( "\n[" __TX_FILELINE__ ": " #__VA_ARGS__ "]...\n", __TX_FUNCTION__);                                                                      __VA_ARGS__
 
#define $n                   { ::std::cerr << "\n";   }
#define $nn                  { ::std::cerr << "\n\n"; }
#define $t                   { ::std::cerr << "\t";   }
 
//-----------------------------------------------------------------------------------------------------------------
 
// This will never be documented, he-he. Read the source, Luke.
 
#if defined (_DEBUG)
    #define $debug       if (1)
    #define $printf      if (1)
    #define $PRINTF      if (1)
#else
    #define $debug       if (0)
    #define $printf      if (0)
    #define $PRINTF      if (0)
#endif
 
#define $$d              $debug
#define $$w              $$$$
#define $$s              __TX_FILELINE__
#define $$b              DebugBreak()
#define $$p              { if (txMessageBox (__TX_FILELINE__ "\n\n" "[Ïîâòîð] - ïðîäîëæåíèå ïðîãðàììû,\n" "[Îòìåíà] - îñòàíîâêà", \
                                                              __TX_FUNCTION__, MB_ICONINFORMATION | MB_RETRYCANCEL) == IDCANCEL) ::exit (2); }
#define $$P              (     txMessageBox (__TX_FILELINE__, __TX_FUNCTION__, MB_ICONINFORMATION | MB_YESNOCANCEL) )
#define $ppp             { { $sy; fprintf (stderr, "[%s ""%s: ""Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]", __TX_FILELINE__, __TX_FUNCTION__); } $P; { $sy; fprintf (stderr, "...\n"); } }
#define $pp              { { $sy; fprintf (stderr, "[%04d %s: ""Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]", __LINE__,        __TX_FUNCTION__); } $P; { $sy; fprintf (stderr, "...\n"); } }
#define $p               { { $sy; fprintf (stderr, "[%s ""%s(): Íàæìèòå ëþáóþ êëàâèøó äëÿ ïðîäîëæåíèÿ]", __TX_FILELINE__, __func__);        } $P; { $sy; fprintf (stderr, "...\n"); } }
#define $ppp_            { { $sy; fprintf (stderr, "[%s ""%s]",                                          __TX_FILELINE__, __TX_FUNCTION__); } $P; { $sy; fprintf (stderr, "...\n"); } }
#define $pp_             { { $sy; fprintf (stderr, "[%04d %s]",                                          __LINE__,        __TX_FUNCTION__); } $P; { $sy; fprintf (stderr, "...\n"); } }
#define $p_              { { $sy; fprintf (stderr, "[%s ""%s()]",                                        __TX_FILELINE__, __func__);        } $P; { $sy; fprintf (stderr, "...\n"); } }
#define $P               ( ((int(*)()) (_getch)) () )  // Avoid "return value not used"
 
//-----------------------------------------------------------------------------------------------------------------
 
struct _txSaveConsoleAttr
    {
    unsigned attr_;
 
    inline          _txSaveConsoleAttr()           : attr_ (txGetConsoleAttr ()) {}
    inline explicit _txSaveConsoleAttr (WORD attr) : attr_ (txGetConsoleAttr ()) { txSetConsoleAttr (attr);  }
    inline         ~_txSaveConsoleAttr()                                         { txSetConsoleAttr (attr_); }
    };
 
//-----------------------------------------------------------------------------------------------------------------
 
struct _txDumpVarSuffix
    {
    typedef _txDumpVarSuffix this_t;
 
    const char* suffix_;
 
    inline  explicit _txDumpVarSuffix (const char suffix[] = "") : suffix_ (suffix) { assert (suffix); }
    inline          ~_txDumpVarSuffix()                          { ::std::cerr << suffix_; }
 
            _txDumpVarSuffix (const this_t&) _tx_delete;
    this_t& operator =       (const this_t&) _tx_delete;
    };
 
//-----------------------------------------------------------------------------------------------------------------
 
#define ARGS__  const char* prefix, const char* suffix, std::ios_base::fmtflags flags,                             int deep
#define ARGS_   const char* prefix, const char* suffix, std::ios_base::fmtflags flags = std::ios_base::fmtflags(), int deep = 0
#define VALS_   prefix, suffix, flags, deep
 
template <typename T, typename StreamT> const T&    _txDumpVal (const T&  value, StreamT& stream, ARGS_);
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T> inline const T&               _txDumpVar (const T&            value,          ARGS_)      { _txDumpVal (value, std:: cerr, VALS_); return value; }
template <typename T> inline       T&               _txDumpVar (      T&            value,          ARGS_)      { _txDumpVal (value, std:: cerr, VALS_); return value; }
 
template <int N>      inline const char           (&_txDumpVar (const char        (&value) [N],     ARGS_)) [N] { _txDumpVal (value, std:: cerr, VALS_); return value; }
template <int N>      inline       char           (&_txDumpVar (      char        (&value) [N],     ARGS_)) [N] { _txDumpVal (value, std:: cerr, VALS_); return value; }
 
template <int N>      inline const wchar_t        (&_txDumpVar (const wchar_t     (&value) [N],     ARGS_)) [N] { _txDumpVal (value, std::wcerr, VALS_); return value; }
template <int N>      inline       wchar_t        (&_txDumpVar (      wchar_t     (&value) [N],     ARGS_)) [N] { _txDumpVal (value, std::wcerr, VALS_); return value; }
 
                      inline const wchar_t&         _txDumpVar (const wchar_t&      value,          ARGS_)      { _txDumpVal (value, std::wcerr, VALS_); return value; }
                      inline       wchar_t&         _txDumpVar (      wchar_t&      value,          ARGS_)      { _txDumpVal (value, std::wcerr, VALS_); return value; }
 
                      inline const wchar_t*&        _txDumpVar (const wchar_t*&     value,          ARGS_)      { _txDumpVal (value, std::wcerr, VALS_); return value; }
                      inline       wchar_t*&        _txDumpVar (      wchar_t*&     value,          ARGS_)      { _txDumpVal (value, std::wcerr, VALS_); return value; }
 
                      inline const std::wstring&    _txDumpVar (const std::wstring& value,          ARGS_)      { _txDumpVal (value, std::wcerr, VALS_); return value; }
                      inline       std::wstring&    _txDumpVar (      std::wstring& value,          ARGS_)      { _txDumpVal (value, std::wcerr, VALS_); return value; }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T, typename StreamT> inline void _txDumpVal (const T&            value, StreamT& stream)     {                     stream <<         value;                                    }
template             <typename StreamT> inline void _txDumpVal (const char          value, StreamT& stream)     {                     stream <<  "'" << value <<  "'";                            }
template             <typename StreamT> inline void _txDumpVal (const wchar_t       value, StreamT& stream)     {                     stream << L"'" << value << L"'";                            }
template             <typename StreamT> inline void _txDumpVal (const char*         value, StreamT& stream)     { if (value)          stream <<  '"' << value <<  '"'; else stream <<  "(null)";  }
template             <typename StreamT> inline void _txDumpVal (const wchar_t*      value, StreamT& stream)     { if (value)          stream << L'"' << value << L'"'; else stream << L"(null)";  }
template             <typename StreamT> inline void _txDumpVal (const std::string&  value, StreamT& stream)     { if (value.length()) stream <<  '"' << value <<  '"'; else stream <<  "(empty)"; }
template             <typename StreamT> inline void _txDumpVal (const std::wstring& value, StreamT& stream)     { if (value.length()) stream << L'"' << value << L'"'; else stream << L"(empty)"; }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T, typename StreamT>
inline const T& _txDumpVal (const T& value, StreamT& stream, ARGS__)
    {
    if (_TX_ARGUMENT_FAILED (&value))  return value;
    if (_TX_ARGUMENT_FAILED (&stream)) return value;
    if (_TX_ARGUMENT_FAILED ( prefix)) return value;
    if (_TX_ARGUMENT_FAILED ( suffix)) return value;
 
    $sc;
    if (!deep) stream << prefix;
 
    std::ios_base::fmtflags old = stream.flags ((flags)? flags : stream.flags());
 
    if (!_txIsBadReadPtr (&value))
        {
        _txDumpVal (value, stream);
        }
    else
        {
        $sE; stream << "<ÍÅÂÅÐÍÛÉ ÀÄÐÅÑ " << &value << ">";
        }
 
    stream.flags (old);
 
    if (!deep) stream << ((*suffix == ']')? "" : ": ") << suffix;
 
    return value;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
template <typename T, int N>
inline T (&_txDumpVar (T (&value) [N], ARGS_)) [N]
    {
    if (_TX_ARGUMENT_FAILED (&value))  return value;
    if (_TX_ARGUMENT_FAILED ( prefix)) return value;
    if (_TX_ARGUMENT_FAILED ( suffix)) return value;
 
    std::ostream& stream = std::cerr;
 
    $sc; if (!deep) std::cerr << prefix;
    $C;  std::cerr << ((deep)? " {" : "{");
 
    if (!_txIsBadReadPtr (value))
        {
        for (int i = 0; ; i++)
            {
            { $sC; stream << "[" << i << "]="; }
 
            _txDumpVar (value[i], prefix, suffix, flags, deep+1);
 
            if (i >= N-1) break;
 
            stream << ", ";
            }
        }
    else
        {
        $sE; stream << "<ÍÅÂÅÐÍÛÉ ÀÄÐÅÑ " << &value << ">";
        }
 
    $C; std::cerr << "}";
    $c; if (!deep) std::cerr << ((*suffix == ']')? "" : ": ") << suffix;
 
    return value;
    }
 
#undef ARGS__
#undef ARGS_
#undef VALS_
 
//=================================================================================================================
 
inline std::ostream& operator << (std::ostream& stream, const POINT& point)
    {
    if (_TX_ARGUMENT_FAILED (&stream)) return stream;
    if (_TX_ARGUMENT_FAILED (&point))  return stream;
 
    if (&point) stream << "{ x: " << point.x << ", y: " << point.y << " }";
    else        stream << "(null)";
 
    return stream;
    }
 
inline std::ostream& operator << (std::ostream& stream, const SIZE& size)
    {
    if (_TX_ARGUMENT_FAILED (&stream)) return stream;
    if (_TX_ARGUMENT_FAILED (&size))   return stream;
 
    if (&size) stream << "{ cx: " << size.cx << ", cy: " << size.cy << " }";
    else       stream << "(null)";
 
    return stream;
    }
 
inline std::ostream& operator << (std::ostream& stream, const RECT& rect)
    {
    if (_TX_ARGUMENT_FAILED (&stream)) return stream;
    if (_TX_ARGUMENT_FAILED (&rect))   return stream;
 
    if (&rect) stream << "{ left: "  << rect.left  << ", top: "    << rect.top    <<
                         ", right: " << rect.right << ", bottom: " << rect.bottom << " }";
 
    else       stream << "(null)";
 
    return stream;
    }
 
//-----------------------------------------------------------------------------------------------------------------
 
#endif
 
//}
//=================================================================================================================
 
 
//=================================================================================================================
//{          TXAPI calls tracing
//           Òðàññèðîâêà âûçîâîâ TXAPI
//=================================================================================================================
 
#ifndef FOR_DOXYGEN_ONLY
 
#if defined (_MSC_VER)
#undef  _txLocCurSet
#define _txLocCurSet()                 __txLocCurSet (__FILE__, __LINE__, NULL)
#endif
 
#define txAlphaBlend(...)              ( _txLocCurSet(), txAlphaBlend          (__VA_ARGS__) )
#define txArc(...)                     ( _txLocCurSet(), txArc                 (__VA_ARGS__) )
#define txBegin(...)                   ( _txLocCurSet(), txBegin               (__VA_ARGS__) )
#define txBitBlt(...)                  ( _txLocCurSet(), txBitBlt              (__VA_ARGS__) )
#define txChord(...)                   ( _txLocCurSet(), txChord               (__VA_ARGS__) )
#define txCircle(...)                  ( _txLocCurSet(), txCircle              (__VA_ARGS__) )
#define txClear(...)                   ( _txLocCurSet(), txClear               (__VA_ARGS__) )
#define txClearConsole(...)            ( _txLocCurSet(), txClearConsole        (__VA_ARGS__) )
#define txColor(...)                   ( _txLocCurSet(), txColor               (__VA_ARGS__) )
#define txCreateCompatibleDC(...)      ( _txLocCurSet(), txCreateCompatibleDC  (__VA_ARGS__) )
#define txCreateDIBSection(...)        ( _txLocCurSet(), txCreateDIBSection    (__VA_ARGS__) )
#define txCreateExtraWindow(...)       ( _txLocCurSet(), txCreateExtraWindow   (__VA_ARGS__) )
#define txCreateExtraWindow(...)       ( _txLocCurSet(), txCreateExtraWindow   (__VA_ARGS__) )
#define txCreateWindow(...)            ( _txLocCurSet(), txCreateWindow        (__VA_ARGS__) )
#define txDC(...)                      ( _txLocCurSet(), txDC                  (__VA_ARGS__) )
#define txDeleteDC(...)                ( _txLocCurSet(), txDeleteDC            (__VA_ARGS__) )
#define txDemangle(...)                ( _txLocCurSet(), txDemangle            (__VA_ARGS__) )
#define txDestroyWindow(...)           ( _txLocCurSet(), txDestroyWindow       (__VA_ARGS__) )
#define txDisableAutoPause(...)        ( _txLocCurSet(), txDisableAutoPause    (__VA_ARGS__) )
#define txDrawText(...)                ( _txLocCurSet(), txDrawText            (__VA_ARGS__) )
#define txEllipse(...)                 ( _txLocCurSet(), txEllipse             (__VA_ARGS__) )
#define txEnd(...)                     ( _txLocCurSet(), txEnd                 (__VA_ARGS__) )
#define txExtractColor(...)            ( _txLocCurSet(), txExtractColor        (__VA_ARGS__) )
#define txFillColor(...)               ( _txLocCurSet(), txFillColor           (__VA_ARGS__) )
#define txFloodFill(...)               ( _txLocCurSet(), txFloodFill           (__VA_ARGS__) )
#define txFontExist(...)               ( _txLocCurSet(), txFontExist           (__VA_ARGS__) )
#define txFormat(...)                  ( _txLocCurSet(), txFormat              (__VA_ARGS__) )
#define txGetAsyncKeyState(...)        ( _txLocCurSet(), txGetAsyncKeyState    (__VA_ARGS__) )
#define txGetColor(...)                ( _txLocCurSet(), txGetColor            (__VA_ARGS__) )
#define txGetConsoleAttr(...)          ( _txLocCurSet(), txGetConsoleAttr      (__VA_ARGS__) )
#define txGetConsoleCursorPos(...)     ( _txLocCurSet(), txGetConsoleCursorPos (__VA_ARGS__) )
#define txGetConsoleExtent(...)        ( _txLocCurSet(), txGetConsoleExtent    (__VA_ARGS__) )
#define txGetConsoleFontSize(...)      ( _txLocCurSet(), txGetConsoleFontSize  (__VA_ARGS__) )
#define txGetExtent(...)               ( _txLocCurSet(), txGetExtent           (__VA_ARGS__) )
#define txGetExtentX(...)              ( _txLocCurSet(), txGetExtentX          (__VA_ARGS__) )
#define txGetExtentY(...)              ( _txLocCurSet(), txGetExtentY          (__VA_ARGS__) )
#define txGetFillColor(...)            ( _txLocCurSet(), txGetFillColor        (__VA_ARGS__) )
#define txGetFPS(...)                  ( _txLocCurSet(), txGetFPS              (__VA_ARGS__) )
#define txGetModuleFileName(...)       ( _txLocCurSet(), txGetModuleFileName   (__VA_ARGS__) )
#define txGetPixel(...)                ( _txLocCurSet(), txGetPixel            (__VA_ARGS__) )
#define txGetTextExtent(...)           ( _txLocCurSet(), txGetTextExtent       (__VA_ARGS__) )
#define txGetTextExtentX(...)          ( _txLocCurSet(), txGetTextExtentX      (__VA_ARGS__) )
#define txGetTextExtentY(...)          ( _txLocCurSet(), txGetTextExtentY      (__VA_ARGS__) )
#define txHSL2RGB(...)                 ( _txLocCurSet(), txHSL2RGB             (__VA_ARGS__) )
#define txInputBox(...)                ( _txLocCurSet(), txInputBox            (__VA_ARGS__) )
#define txLine(...)                    ( _txLocCurSet(), txLine                (__VA_ARGS__) )
#define txLoadImage(...)               ( _txLocCurSet(), txLoadImage           (__VA_ARGS__) )
#define txLock(...)                    ( _txLocCurSet(), txLock                (__VA_ARGS__) )
#define txMessageBox(...)              ( _txLocCurSet(), txMessageBox          (__VA_ARGS__) )
#define txMouseButtons(...)            ( _txLocCurSet(), txMouseButtons        (__VA_ARGS__) )
#define txMousePos(...)                ( _txLocCurSet(), txMousePos            (__VA_ARGS__) )
#define txMouseX(...)                  ( _txLocCurSet(), txMouseX              (__VA_ARGS__) )
#define txMouseY(...)                  ( _txLocCurSet(), txMouseY              (__VA_ARGS__) )
#define txNotifyIcon(...)              ( _txLocCurSet(), txNotifyIcon          (__VA_ARGS__) )
#define txOK(...)                      ( _txLocCurSet(), txOK                  (__VA_ARGS__) )
#define txOutputDebugPrintf(...)       ( _txLocCurSet(), txOutputDebugPrintf   (__VA_ARGS__) )
#define txPie(...)                     ( _txLocCurSet(), txPie                 (__VA_ARGS__) )
#define txPixel(...)                   ( _txLocCurSet(), txPixel               (__VA_ARGS__) )
#define txPlaySound(...)               ( _txLocCurSet(), txPlaySound           (__VA_ARGS__) )
#define txPlayVideo(...)               ( _txLocCurSet(), txPlayVideo           (__VA_ARGS__) )
#define txPolygon(...)                 ( _txLocCurSet(), txPolygon             (__VA_ARGS__) )
#define txPrintf(...)                  ( _txLocCurSet(), txPrintf              (__VA_ARGS__) )
#define txQueryPerformance(...)        ( _txLocCurSet(), txQueryPerformance    (__VA_ARGS__) )
#define txRectangle(...)               ( _txLocCurSet(), txRectangle           (__VA_ARGS__) )
#define txRedrawWindow(...)            ( _txLocCurSet(), txRedrawWindow        (__VA_ARGS__) )
#define txRegisterClass(...)           ( _txLocCurSet(), txRegisterClass       (__VA_ARGS__) )
#define txRegisterClass(...)           ( _txLocCurSet(), txRegisterClass       (__VA_ARGS__) )
#define txRegQuery(...)                ( _txLocCurSet(), txRegQuery            (__VA_ARGS__) )
#define txReopenStdio(...)             ( _txLocCurSet(), txReopenStdio         (__VA_ARGS__) )
#define txReopenStdio(...)             ( _txLocCurSet(), txReopenStdio         (__VA_ARGS__) )
#define txRGB2HSL(...)                 ( _txLocCurSet(), txRGB2HSL             (__VA_ARGS__) )
#define txSaveImage(...)               ( _txLocCurSet(), txSaveImage           (__VA_ARGS__) )
#define txSelectFont(...)              ( _txLocCurSet(), txSelectFont          (__VA_ARGS__) )
#define txSelectObject(...)            ( _txLocCurSet(), txSelectObject        (__VA_ARGS__) )
#define txSetColor(...)                ( _txLocCurSet(), txSetColor            (__VA_ARGS__) )
#define txSetConsoleAttr(...)          ( _txLocCurSet(), txSetConsoleAttr      (__VA_ARGS__) )
#define txSetConsoleCursorPos(...)     ( _txLocCurSet(), txSetConsoleCursorPos (__VA_ARGS__) )
#define txSetDefaults(...)             ( _txLocCurSet(), txSetDefaults         (__VA_ARGS__) )
#define txSetFillColor(...)            ( _txLocCurSet(), txSetFillColor        (__VA_ARGS__) )
#define txSetLocale(...)               ( _txLocCurSet(), txSetLocale           (__VA_ARGS__) )
#define txSetPixel(...)                ( _txLocCurSet(), txSetPixel            (__VA_ARGS__) )
#define txSetTextAlign(...)            ( _txLocCurSet(), txSetTextAlign        (__VA_ARGS__) )
#define txSetWindowsHook(...)          ( _txLocCurSet(), txSetWindowsHook      (__VA_ARGS__) )
#define txSleep(...)                   ( _txLocCurSet(), txSleep               (__VA_ARGS__) )
#define txSpeak(...)                   ( _txLocCurSet(), txSpeak               (__VA_ARGS__) )
#define txTaskKill(...)                ( _txLocCurSet(), txTaskKill            (__VA_ARGS__) )
#define txTextCursor(...)              ( _txLocCurSet(), txTextCursor          (__VA_ARGS__) )
#define txTextOut(...)                 ( _txLocCurSet(), txTextOut             (__VA_ARGS__) )
#define txTransparentBlt(...)          ( _txLocCurSet(), txTransparentBlt      (__VA_ARGS__) )
#define txTriangle(...)                ( _txLocCurSet(), txTriangle            (__VA_ARGS__) )
#define txUnlock(...)                  ( _txLocCurSet(), txUnlock              (__VA_ARGS__) )
#define txUpdateWindow(...)            ( _txLocCurSet(), txUpdateWindow        (__VA_ARGS__) )
#define txUseAlpha(...)                ( _txLocCurSet(), txUseAlpha            (__VA_ARGS__) )
#define txVersion(...)                 ( _txLocCurSet(), txVersion             (__VA_ARGS__) )
#define txVersionNumber(...)           ( _txLocCurSet(), txVersionNumber       (__VA_ARGS__) )
#define txWindow(...)                  ( _txLocCurSet(), txWindow              (__VA_ARGS__) )
#define tx_fpreset(...)                ( _txLocCurSet(), tx_fpreset            (__VA_ARGS__) )
#define tx_glGetError(...)             ( _txLocCurSet(), tx_glGetError         (__VA_ARGS__) )
#define _txDump(...)                   ( _txLocCurSet(), _txDump               (__VA_ARGS__) )
#define _txStackBackTrace(...)         ( _txLocCurSet(), _txStackBackTrace     (__VA_ARGS__) )
 
#endif
 
//}
//=================================================================================================================
 
//}
//=================================================================================================================
 
} }  // namespace TX, anonymous namespace
 
//-----------------------------------------------------------------------------------------------------------------
//{          The namespaces: easy using of TX:: and some of std::
//-----------------------------------------------------------------------------------------------------------------
 
using namespace TX;                    // Allow easy usage of TXLib functions
 
using ::std::cin;                      // Predefined usings to avoid "using namespace std"                         
using ::std::cout;                                                                                                 
using ::std::cerr;                                                                                                 
using ::std::string;                                                                                               
using ::std::wcin;                                                                                                 
using ::std::wcout;                                                                                                
using ::std::wcerr;                                                                                                
using ::std::wstring;                                                                                              
                                                                                                                   
//}                                                                                                                
//-----------------------------------------------------------------------------------------------------------------
                                                                                                                   
//-----------------------------------------------------------------------------------------------------------------
//{          Compiler- and platform-specific                                                                       
//           Àäàïòàöèÿ ê êîìïèëÿòîðàì è ïëàòôîðìàì                                                                 
//-----------------------------------------------------------------------------------------------------------------
                                                                                                                   
#if defined (_GCC_VER)                                                                                             
                                                                                                                   
    #pragma GCC optimize               "strict-aliasing"                                                           
                                                                                                                   
    #pragma GCC pop_options                                                                                        
    #pragma GCC diagnostic pop                                                                                     
                                                                                                                   
    #endif                                                                                                         
                                                                                                                   
#if defined (_CLANG_VER)                                                                                           
                                                                                                                   
    #pragma clang diagnostic pop                                                                                   
                                                                                                                   
    #endif                                                                                                         
                                                                                                                   
//-----------------------------------------------------------------------------------------------------------------
                                                                                                                   
#if defined (_MSC_VER)                                                                                             
                                                                                                                   
    #pragma warning (pop)              // Restoring maximum level                                                  
                                                                                                                   
    #endif                                                                                                         
                                                                                                                   
#if defined (__INTEL_COMPILER)                                                                                     
                                                                                                                   
    #pragma warning (default:  174)    // Remark: expression has no effect                                         
    #pragma warning (default:  304)    // Remark: access control not specified ("public" by default)               
    #pragma warning (default:  444)    // Remark: destructor for base class "..." is not virtual                   
    #pragma warning (default:  522)    // Remark: function redeclared "inline" after being called                  
    #pragma warning (default: 1684)    // Conversion from pointer to same-sized integral type (potential portability problem)
                                                                                                                   
    #pragma warning (disable:  981)    // Remark: operands are evaluated in unspecified order                      
                                                                                                                   
    #endif                                                                                                         
                                                                                                                   
//}                                                                                                                
//-----------------------------------------------------------------------------------------------------------------
                                                                                                                   
#endif // __TXLIB_H_INCLUDED                                                                                       
                                                                                                                   
//=================================================================================================================
// EOF                                                                                                             
//=================================================================================================================